← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to bzrtools.py

  • Committer: Aaron Bentley
  • Date: 2007-06-12 22:09:44 UTC
  • mfrom: (540.1.2 bzrtools-0.17)
  • Revision ID: aaron.bentley@utoronto.ca-20070612220944-5zw4hlzp1ctq6mkl
Merge fixes from 0.17

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrtools.py
1
 
# Copyright (C) 2005 Aaron Bentley
2
 
# <aaron.bentley@utoronto.ca>
 
1
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron.bentley@utoronto.ca>
 
2
# Copyright (C) 2007 John Arbash Meinel
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
25
25
 
26
26
import bzrlib
27
27
import bzrlib.errors
28
 
from bzrlib.errors import BzrCommandError
29
 
from bzrlib.bzrdir import BzrDir
 
28
from bzrlib.errors import (BzrCommandError, NotBranchError, NoSuchFile,
 
29
                           UnsupportedFormatError, TransportError,
 
30
                           NoWorkingTree, PermissionDenied)
 
31
from bzrlib.bzrdir import BzrDir, BzrDirFormat
30
32
 
31
33
def temp_tree():
32
34
    dirname = tempfile.mkdtemp("temp-branch")
38
40
def is_clean(cur_tree):
39
41
    """
40
42
    Return true if no files are modifed or unknown
41
 
    >>> import bzrlib.add
42
 
    >>> tree = temp_tree()
43
 
    >>> is_clean(tree)
44
 
    (True, [])
45
 
    >>> fooname = os.path.join(tree.basedir, "foo")
46
 
    >>> file(fooname, "wb").write("bar")
47
 
    >>> is_clean(tree)
48
 
    (True, [u'foo'])
49
 
    >>> bzrlib.add.smart_add_tree(tree, [tree.basedir])
50
 
    ([u'foo'], {})
51
 
    >>> is_clean(tree)
52
 
    (False, [])
53
 
    >>> tree.commit("added file")
54
 
    >>> is_clean(tree)
55
 
    (True, [])
56
 
    >>> rm_tree(tree)
57
43
    """
58
 
    from bzrlib.diff import compare_trees
59
44
    old_tree = cur_tree.basis_tree()
60
45
    new_tree = cur_tree
61
46
    non_source = []
62
 
    for path, file_class, kind, file_id, entry in new_tree.list_files():
63
 
        if file_class in ('?', 'I'):
64
 
            non_source.append(path)
65
 
    delta = compare_trees(old_tree, new_tree, want_unchanged=False)
 
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()
66
55
    return not delta.has_changed(), non_source
67
56
 
68
57
def set_push_data(tree, location):
69
 
    push_file = file (tree._control_files.controlfilename("x-push-data"), "wb")
70
 
    push_file.write("%s\n" % location)
 
58
    tree.branch.control_files.put_utf8("x-push-data", "%s\n" % location)
71
59
 
72
60
def get_push_data(tree):
73
61
    """
76
64
    True
77
65
    >>> set_push_data(tree, 'http://somewhere')
78
66
    >>> get_push_data(tree)
79
 
    'http://somewhere'
 
67
    u'http://somewhere'
80
68
    >>> rm_tree(tree)
81
69
    """
82
 
    filename = tree._control_files.controlfilename("x-push-data")
83
 
    if not os.path.exists(filename):
 
70
    try:
 
71
        location = tree.branch.control_files.get_utf8('x-push-data').read()
 
72
    except NoSuchFile:
84
73
        return None
85
 
    push_file = file (filename, "rb")
86
 
    (location,) = [f.rstrip('\n') for f in push_file]
87
 
    return location
 
74
    return location.rstrip('\n')
88
75
 
89
76
"""
90
77
>>> shell_escape('hello')
112
99
    def __init__(self, rsync_name):
113
100
        Exception.__init__(self, "%s not found." % rsync_name)
114
101
 
115
 
def rsync(source, target, ssh=False, excludes=(), silent=False, 
 
102
def rsync(source, target, ssh=False, excludes=(), silent=False,
116
103
          rsync_name="rsync"):
117
104
    """
118
105
    >>> new_dir = tempfile.mkdtemp()
121
108
    >>> rsync("a", "b", silent=True)
122
109
    Traceback (most recent call last):
123
110
    RsyncNoFile: No such file...
124
 
    >>> rsync(tempdir + "/a", tempdir + "/b", excludes=("*.py",), silent=True) #doctest: +ELLIPSIS
 
111
    >>> rsync(new_dir + "/a", new_dir + "/b", excludes=("*.py",), silent=True)
125
112
    Traceback (most recent call last):
126
113
    RsyncNoFile: No such file...
127
 
    >>> rsync(tempdir + "/a", tempdir + "/b", excludes=("*.py",), silent=True, rsync_name="rsyncc")
 
114
    >>> rsync(new_dir + "/a", new_dir + "/b", excludes=("*.py",), silent=True, rsync_name="rsyncc")
128
115
    Traceback (most recent call last):
129
116
    NoRsync: rsyncc not found.
130
117
    >>> os.chdir(old_dir)
147
134
    except OSError, e:
148
135
        if e.errno == errno.ENOENT:
149
136
            raise NoRsync(rsync_name)
150
 
            
 
137
 
151
138
    proc.stdin.write('\n'.join(excludes)+'\n')
152
139
    proc.stdin.close()
153
140
    if silent:
189
176
        raise RsyncUnknownStatus(proc.returncode)
190
177
    return [l.split(' ')[-1].rstrip('\n') for l in result.splitlines(True)]
191
178
 
192
 
exclusions = ('.bzr/x-push-data', '.bzr/parent', '.bzr/x-pull-data', 
193
 
              '.bzr/x-pull', '.bzr/pull', '.bzr/stat-cache',
194
 
              '.bzr/x-rsync-data')
 
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')
195
183
 
196
184
 
197
185
def read_revision_history(fname):
210
198
    tempdir = tempfile.mkdtemp('push')
211
199
    try:
212
200
        history_fname = os.path.join(tempdir, 'revision-history')
213
 
        cmd = rsync(location+'.bzr/revision-history', history_fname,
214
 
                    silent=True)
 
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)
215
207
        history = read_revision_history(history_fname)
216
208
    finally:
217
209
        shutil.rmtree(tempdir)
224
216
        return False
225
217
    for local, remote in zip(remote_history, local_history):
226
218
        if local != remote:
227
 
            return False 
 
219
            return False
228
220
    return True
229
221
 
230
222
def empty_or_absent(location):
234
226
    except RsyncNoFile:
235
227
        return True
236
228
 
237
 
def push(tree, location=None, overwrite=False, working_tree=True):
 
229
def rspush(tree, location=None, overwrite=False, working_tree=True):
238
230
    push_location = get_push_data(tree)
239
231
    if location is not None:
240
232
        if not location.endswith('/'):
241
233
            location += '/'
242
234
        push_location = location
243
 
    
 
235
 
244
236
    if push_location is None:
245
 
        if tree.branch.get_push_location() is None:
246
 
            raise BzrCommandError("No push location known or specified.")
247
 
        else:
248
 
            raise bzrlib.errors.MustUseDecorated
249
 
 
250
 
    if push_location.find('://') != -1:
251
 
        raise bzrlib.errors.MustUseDecorated
252
 
 
253
 
    if push_location.find(':') == -1:
254
 
        raise bzrlib.errors.MustUseDecorated
255
 
 
256
 
    clean, non_source = is_clean(tree)
257
 
    if not clean:
258
 
        print """Error: This tree has uncommitted changes or unknown (?) files.
259
 
Use "bzr status" to list them."""
260
 
        sys.exit(1)
 
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
 
261
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)
262
254
        final_exclusions = non_source[:]
263
255
    else:
264
256
        wt = tree
283
275
                " specified location.  Please ensure that"
284
276
                ' "%s" is of the form "machine:/path".' % push_location)
285
277
    print "Pushing to %s" % push_location
286
 
    rsync(tree.basedir+'/', push_location, ssh=True, 
 
278
    rsync(tree.basedir+'/', push_location, ssh=usessh,
287
279
          excludes=final_exclusions)
288
280
 
289
281
    set_push_data(tree, push_location)
296
288
    return new_committer
297
289
 
298
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
 
 
364
 
299
365
def run_tests():
300
366
    import doctest
301
367
    result = doctest.testmod()