← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to bzrtools.py

  • Committer: Aaron Bentley
  • Date: 2013-08-20 03:02:43 UTC
  • Revision ID: aaron@aaronbentley.com-20130820030243-r8v1xfbcnd8f10p4
Fix zap command for 2.6/7

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrtools.py
1
 
# Copyright (C) 2005, 2006, 2007 Aaron Bentley <aaron.bentley@utoronto.ca>
 
1
# Copyright (C) 2005-2009, 2011-2013 Aaron Bentley <aaron@aaronbentley.com>
2
2
# Copyright (C) 2007 John Arbash Meinel
3
3
#
4
4
#    This program is free software; you can redistribute it and/or modify
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
19
 
import os
 
17
from contextlib import contextmanager
20
18
import re
21
 
import tempfile
22
 
import shutil
23
 
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():
34
 
    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):
41
 
    """
42
 
    Return true if no files are modifed or unknown
43
 
    """
44
 
    old_tree = cur_tree.basis_tree()
45
 
    new_tree = cur_tree
46
 
    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
64
 
    True
65
 
    >>> set_push_data(tree, 'http://somewhere')
66
 
    >>> get_push_data(tree)
67
 
    u'http://somewhere'
68
 
    >>> rm_tree(tree)
69
 
    """
70
 
    try:
71
 
        location = tree.branch.control_files.get_utf8('x-push-data').read()
72
 
    except NoSuchFile:
73
 
        return None
74
 
    return location.rstrip('\n')
75
 
 
76
 
"""
77
 
>>> shell_escape('hello')
78
 
'\h\e\l\l\o'
79
 
"""
80
 
def shell_escape(arg):
81
 
    return "".join(['\\'+c for c in arg])
82
 
 
83
 
def safe_system(args):
84
 
    """
85
 
    >>> real_system = os.system
86
 
    >>> os.system = sys.stdout.write
87
 
    >>> safe_system(['a', 'b', 'cd'])
88
 
    \\a \\b \\c\\d
89
 
    >>> os.system = real_system
90
 
    """
91
 
    arg_str = " ".join([shell_escape(a) for a in args])
92
 
    return os.system(arg_str)
93
 
 
94
 
class RsyncUnknownStatus(Exception):
95
 
    def __init__(self, status):
96
 
        Exception.__init__(self, "Unknown status: %d" % status)
97
 
 
98
 
class NoRsync(Exception):
99
 
    def __init__(self, rsync_name):
100
 
        Exception.__init__(self, "%s not found." % rsync_name)
101
 
 
102
 
def rsync(source, target, ssh=False, excludes=(), silent=False,
103
 
          rsync_name="rsync"):
104
 
    """
105
 
    >>> new_dir = tempfile.mkdtemp()
106
 
    >>> old_dir = os.getcwd()
107
 
    >>> os.chdir(new_dir)
108
 
    >>> rsync("a", "b", silent=True)
109
 
    Traceback (most recent call last):
110
 
    RsyncNoFile: No such file...
111
 
    >>> rsync(new_dir + "/a", new_dir + "/b", excludes=("*.py",), silent=True)
112
 
    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")
115
 
    Traceback (most recent call last):
116
 
    NoRsync: rsyncc not found.
117
 
    >>> os.chdir(old_dir)
118
 
    >>> os.rmdir(new_dir)
119
 
    """
120
 
    cmd = [rsync_name, "-av", "--delete"]
121
 
    if ssh:
122
 
        cmd.extend(('-e', 'ssh'))
123
 
    if len(excludes) > 0:
124
 
        cmd.extend(('--exclude-from', '-'))
125
 
    cmd.extend((source, target))
126
 
    if silent:
127
 
        stderr = PIPE
128
 
        stdout = PIPE
129
 
    else:
130
 
        stderr = None
131
 
        stdout = None
132
 
    try:
133
 
        proc = Popen(cmd, stdin=PIPE, stderr=stderr, stdout=stdout)
134
 
    except OSError, e:
135
 
        if e.errno == errno.ENOENT:
136
 
            raise NoRsync(rsync_name)
137
 
 
138
 
    proc.stdin.write('\n'.join(excludes)+'\n')
139
 
    proc.stdin.close()
140
 
    if silent:
141
 
        proc.stderr.read()
142
 
        proc.stderr.close()
143
 
        proc.stdout.read()
144
 
        proc.stdout.close()
145
 
    proc.wait()
146
 
    if proc.returncode == 12:
147
 
        raise RsyncStreamIO()
148
 
    elif proc.returncode == 23:
149
 
        raise RsyncNoFile(source)
150
 
    elif proc.returncode != 0:
151
 
        raise RsyncUnknownStatus(proc.returncode)
152
 
    return cmd
153
 
 
154
 
 
155
 
def rsync_ls(source, ssh=False, silent=True):
156
 
    cmd = ["rsync"]
157
 
    if ssh:
158
 
        cmd.extend(('-e', 'ssh'))
159
 
    cmd.append(source)
160
 
    if silent:
161
 
        stderr = PIPE
162
 
    else:
163
 
        stderr = None
164
 
    proc = Popen(cmd, stderr=stderr, stdout=PIPE)
165
 
    result = proc.stdout.read()
166
 
    proc.stdout.close()
167
 
    if silent:
168
 
        proc.stderr.read()
169
 
        proc.stderr.close()
170
 
    proc.wait()
171
 
    if proc.returncode == 12:
172
 
        raise RsyncStreamIO()
173
 
    elif proc.returncode == 23:
174
 
        raise RsyncNoFile(source)
175
 
    elif proc.returncode != 0:
176
 
        raise RsyncUnknownStatus(proc.returncode)
177
 
    return [l.split(' ')[-1].rstrip('\n') for l in result.splitlines(True)]
178
 
 
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')
183
 
 
184
 
 
185
 
def read_revision_history(fname):
186
 
    return [l.rstrip('\r\n') for l in
187
 
            codecs.open(fname, 'rb', 'utf-8').readlines()]
188
 
 
189
 
class RsyncNoFile(Exception):
190
 
    def __init__(self, path):
191
 
        Exception.__init__(self, "No such file %s" % path)
192
 
 
193
 
class RsyncStreamIO(Exception):
194
 
    def __init__(self):
195
 
        Exception.__init__(self, "Error in rsync protocol data stream.")
196
 
 
197
 
def get_revision_history(location):
198
 
    tempdir = tempfile.mkdtemp('push')
199
 
    try:
200
 
        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)
207
 
        history = read_revision_history(history_fname)
208
 
    finally:
209
 
        shutil.rmtree(tempdir)
210
 
    return history
211
 
 
212
 
def history_subset(location, branch):
213
 
    remote_history = get_revision_history(location)
214
 
    local_history = branch.revision_history()
215
 
    if len(remote_history) > len(local_history):
216
 
        return False
217
 
    for local, remote in zip(remote_history, local_history):
218
 
        if local != remote:
219
 
            return False
220
 
    return True
221
 
 
222
 
def empty_or_absent(location):
223
 
    try:
224
 
        files = rsync_ls(location)
225
 
        return files == ['.']
226
 
    except RsyncNoFile:
227
 
        return True
228
 
 
229
 
def rspush(tree, location=None, overwrite=False, working_tree=True):
230
 
    push_location = get_push_data(tree)
231
 
    if location is not None:
232
 
        if not location.endswith('/'):
233
 
            location += '/'
234
 
        push_location = location
235
 
 
236
 
    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
 
    if not overwrite:
263
 
        try:
264
 
            if not history_subset(push_location, tree.branch):
265
 
                raise bzrlib.errors.BzrCommandError("Local branch is not a"
266
 
                                                    " newer version of remote"
267
 
                                                    " branch.")
268
 
        except RsyncNoFile:
269
 
            if not empty_or_absent(push_location):
270
 
                raise bzrlib.errors.BzrCommandError("Remote location is not a"
271
 
                                                    " bzr branch (or empty"
272
 
                                                    " directory)")
273
 
        except RsyncStreamIO:
274
 
            raise bzrlib.errors.BzrCommandError("Rsync could not use the"
275
 
                " specified location.  Please ensure that"
276
 
                ' "%s" is of the form "machine:/path".' % push_location)
277
 
    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)
 
19
 
 
20
from bzrlib import urlutils
 
21
from bzrlib.errors import (
 
22
    BzrCommandError,
 
23
    NotBranchError,
 
24
    NoSuchFile,
 
25
    )
 
26
from bzrlib.bzrdir import BzrDir
 
27
from bzrlib.transport import get_transport
 
28
 
 
29
 
 
30
@contextmanager
 
31
def read_locked(lockable):
 
32
    """Read-lock a tree, branch or repository in this context."""
 
33
    lockable.lock_read()
 
34
    try:
 
35
        yield lockable
 
36
    finally:
 
37
        lockable.unlock()
282
38
 
283
39
 
284
40
def short_committer(committer):
292
48
    """Screen-scrape Apache listings"""
293
49
    apache_dir = '<img border="0" src="/icons/folder.gif" alt="[dir]">'\
294
50
        ' <a href="'
295
 
    lines = t.get('.')
296
 
    expr = re.compile('<a[^>]*href="([^>]*)"[^>]*>', flags=re.I)
 
51
    t = t.clone()
 
52
    t._remote_path = lambda x: t.base
 
53
    try:
 
54
        lines = t.get('')
 
55
    except NoSuchFile:
 
56
        return
 
57
    expr = re.compile('<a[^>]*href="([^>]*)\/"[^>]*>', flags=re.I)
297
58
    for line in lines:
298
59
        match = expr.search(line)
299
60
        if match is None:
306
67
        yield url.rstrip('/')
307
68
 
308
69
 
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
 
70
def list_branches(t):
 
71
    def is_inside(branch):
 
72
        return bool(branch.base.startswith(t.base))
 
73
 
 
74
    if t.base.startswith('http://'):
 
75
        def evaluate(bzrdir):
 
76
            try:
 
77
                branch = bzrdir.open_branch()
 
78
                if is_inside(branch):
 
79
                    return True, branch
 
80
                else:
 
81
                    return True, None
 
82
            except NotBranchError:
 
83
                return True, None
 
84
        return [b for b in BzrDir.find_bzrdirs(t, list_current=apache_ls,
 
85
                evaluate=evaluate) if b is not None]
 
86
    elif not t.listable():
 
87
        raise BzrCommandError("Can't list this type of location.")
 
88
    return [b for b in BzrDir.find_branches(t) if is_inside(b)]
 
89
 
 
90
 
 
91
def evaluate_branch_tree(bzrdir):
 
92
    try:
 
93
        tree, branch = bzrdir._get_tree_branch()
 
94
    except NotBranchError:
 
95
        return True, None
 
96
    else:
 
97
        return True, (branch, tree)
318
98
 
319
99
 
320
100
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)
 
101
    return (x for x in BzrDir.find_bzrdirs(t, evaluate=evaluate_branch_tree,
 
102
            list_current=lister) if x is not None)
 
103
 
 
104
 
 
105
def open_from_url(location):
 
106
    location = urlutils.normalize_url(location)
 
107
    dirname, basename = urlutils.split(location)
 
108
    if location.endswith('/') and not basename.endswith('/'):
 
109
        basename += '/'
 
110
    return get_transport(dirname).get(basename)
363
111
 
364
112
 
365
113
def run_tests():