/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

[merge] trace improvements

 - shorter error messages on exceptions

 - shorter display of status and time in selftest output

 - send debug output direct to file to reduce cost of going
   through Python logging

 - always send exception tracebacks to trace file

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import shutil
 
19
import sys
 
20
import os
 
21
import errno
 
22
from warnings import warn
 
23
from cStringIO import StringIO
 
24
 
 
25
 
 
26
import bzrlib
 
27
from bzrlib.inventory import InventoryEntry
 
28
import bzrlib.inventory as inventory
 
29
from bzrlib.trace import mutter, note
 
30
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes, 
 
31
                            rename, splitpath, sha_file, appendpath, 
 
32
                            file_kind, abspath)
 
33
import bzrlib.errors as errors
 
34
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
 
35
                           NoSuchRevision, HistoryMissing, NotBranchError,
 
36
                           DivergedBranches, LockError, UnlistableStore,
 
37
                           UnlistableBranch, NoSuchFile, NotVersionedError,
 
38
                           NoWorkingTree)
 
39
from bzrlib.textui import show_status
 
40
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
 
41
                             NULL_REVISION)
 
42
 
 
43
from bzrlib.delta import compare_trees
 
44
from bzrlib.tree import EmptyTree, RevisionTree
 
45
from bzrlib.inventory import Inventory
 
46
from bzrlib.store import copy_all
 
47
from bzrlib.store.text import TextStore
 
48
from bzrlib.store.weave import WeaveStore
 
49
from bzrlib.testament import Testament
 
50
import bzrlib.transactions as transactions
 
51
from bzrlib.transport import Transport, get_transport
 
52
import bzrlib.xml5
 
53
import bzrlib.ui
 
54
from config import TreeConfig
 
55
 
 
56
 
 
57
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
 
58
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
 
59
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
 
60
## TODO: Maybe include checks for common corruption of newlines, etc?
 
61
 
 
62
 
 
63
# TODO: Some operations like log might retrieve the same revisions
 
64
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
65
# cache in memory to make this faster.  In general anything can be
 
66
# cached in memory between lock and unlock operations.
 
67
 
 
68
def find_branch(*ignored, **ignored_too):
 
69
    # XXX: leave this here for about one release, then remove it
 
70
    raise NotImplementedError('find_branch() is not supported anymore, '
 
71
                              'please use one of the new branch constructors')
 
72
 
 
73
 
 
74
def needs_read_lock(unbound):
 
75
    """Decorate unbound to take out and release a read lock."""
 
76
    def decorated(self, *args, **kwargs):
 
77
        self.lock_read()
 
78
        try:
 
79
            return unbound(self, *args, **kwargs)
 
80
        finally:
 
81
            self.unlock()
 
82
    return decorated
 
83
 
 
84
 
 
85
def needs_write_lock(unbound):
 
86
    """Decorate unbound to take out and release a write lock."""
 
87
    def decorated(self, *args, **kwargs):
 
88
        self.lock_write()
 
89
        try:
 
90
            return unbound(self, *args, **kwargs)
 
91
        finally:
 
92
            self.unlock()
 
93
    return decorated
 
94
 
 
95
######################################################################
 
96
# branch objects
 
97
 
 
98
class Branch(object):
 
99
    """Branch holding a history of revisions.
 
100
 
 
101
    base
 
102
        Base directory/url of the branch.
 
103
    """
 
104
    base = None
 
105
 
 
106
    def __init__(self, *ignored, **ignored_too):
 
107
        raise NotImplementedError('The Branch class is abstract')
 
108
 
 
109
    @staticmethod
 
110
    def open_downlevel(base):
 
111
        """Open a branch which may be of an old format.
 
112
        
 
113
        Only local branches are supported."""
 
114
        return BzrBranch(get_transport(base), relax_version_check=True)
 
115
        
 
116
    @staticmethod
 
117
    def open(base):
 
118
        """Open an existing branch, rooted at 'base' (url)"""
 
119
        t = get_transport(base)
 
120
        mutter("trying to open %r with transport %r", base, t)
 
121
        return BzrBranch(t)
 
122
 
 
123
    @staticmethod
 
124
    def open_containing(url):
 
125
        """Open an existing branch which contains url.
 
126
        
 
127
        This probes for a branch at url, and searches upwards from there.
 
128
 
 
129
        Basically we keep looking up until we find the control directory or
 
130
        run into the root.  If there isn't one, raises NotBranchError.
 
131
        If there is one, it is returned, along with the unused portion of url.
 
132
        """
 
133
        t = get_transport(url)
 
134
        while True:
 
135
            try:
 
136
                return BzrBranch(t), t.relpath(url)
 
137
            except NotBranchError:
 
138
                pass
 
139
            new_t = t.clone('..')
 
140
            if new_t.base == t.base:
 
141
                # reached the root, whatever that may be
 
142
                raise NotBranchError(path=url)
 
143
            t = new_t
 
144
 
 
145
    @staticmethod
 
146
    def initialize(base):
 
147
        """Create a new branch, rooted at 'base' (url)"""
 
148
        t = get_transport(base)
 
149
        return BzrBranch(t, init=True)
 
150
 
 
151
    def setup_caching(self, cache_root):
 
152
        """Subclasses that care about caching should override this, and set
 
153
        up cached stores located under cache_root.
 
154
        """
 
155
        self.cache_root = cache_root
 
156
 
 
157
    def _get_nick(self):
 
158
        cfg = self.tree_config()
 
159
        return cfg.get_option(u"nickname", default=self.base.split('/')[-1])
 
160
 
 
161
    def _set_nick(self, nick):
 
162
        cfg = self.tree_config()
 
163
        cfg.set_option(nick, "nickname")
 
164
        assert cfg.get_option("nickname") == nick
 
165
 
 
166
    nick = property(_get_nick, _set_nick)
 
167
        
 
168
    def push_stores(self, branch_to):
 
169
        """Copy the content of this branches store to branch_to."""
 
170
        raise NotImplementedError('push_stores is abstract')
 
171
 
 
172
    def get_transaction(self):
 
173
        """Return the current active transaction.
 
174
 
 
175
        If no transaction is active, this returns a passthrough object
 
176
        for which all data is immediately flushed and no caching happens.
 
177
        """
 
178
        raise NotImplementedError('get_transaction is abstract')
 
179
 
 
180
    def lock_write(self):
 
181
        raise NotImplementedError('lock_write is abstract')
 
182
        
 
183
    def lock_read(self):
 
184
        raise NotImplementedError('lock_read is abstract')
 
185
 
 
186
    def unlock(self):
 
187
        raise NotImplementedError('unlock is abstract')
 
188
 
 
189
    def abspath(self, name):
 
190
        """Return absolute filename for something in the branch
 
191
        
 
192
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
193
        method and not a tree method.
 
194
        """
 
195
        raise NotImplementedError('abspath is abstract')
 
196
 
 
197
    def controlfilename(self, file_or_path):
 
198
        """Return location relative to branch."""
 
199
        raise NotImplementedError('controlfilename is abstract')
 
200
 
 
201
    def controlfile(self, file_or_path, mode='r'):
 
202
        """Open a control file for this branch.
 
203
 
 
204
        There are two classes of file in the control directory: text
 
205
        and binary.  binary files are untranslated byte streams.  Text
 
206
        control files are stored with Unix newlines and in UTF-8, even
 
207
        if the platform or locale defaults are different.
 
208
 
 
209
        Controlfiles should almost never be opened in write mode but
 
210
        rather should be atomically copied and replaced using atomicfile.
 
211
        """
 
212
        raise NotImplementedError('controlfile is abstract')
 
213
 
 
214
    def put_controlfile(self, path, f, encode=True):
 
215
        """Write an entry as a controlfile.
 
216
 
 
217
        :param path: The path to put the file, relative to the .bzr control
 
218
                     directory
 
219
        :param f: A file-like or string object whose contents should be copied.
 
220
        :param encode:  If true, encode the contents as utf-8
 
221
        """
 
222
        raise NotImplementedError('put_controlfile is abstract')
 
223
 
 
224
    def put_controlfiles(self, files, encode=True):
 
225
        """Write several entries as controlfiles.
 
226
 
 
227
        :param files: A list of [(path, file)] pairs, where the path is the directory
 
228
                      underneath the bzr control directory
 
229
        :param encode:  If true, encode the contents as utf-8
 
230
        """
 
231
        raise NotImplementedError('put_controlfiles is abstract')
 
232
 
 
233
    def get_root_id(self):
 
234
        """Return the id of this branches root"""
 
235
        raise NotImplementedError('get_root_id is abstract')
 
236
 
 
237
    def set_root_id(self, file_id):
 
238
        raise NotImplementedError('set_root_id is abstract')
 
239
 
 
240
    def add(self, files, ids=None):
 
241
        """Make files versioned.
 
242
 
 
243
        Note that the command line normally calls smart_add instead,
 
244
        which can automatically recurse.
 
245
 
 
246
        This puts the files in the Added state, so that they will be
 
247
        recorded by the next commit.
 
248
 
 
249
        files
 
250
            List of paths to add, relative to the base of the tree.
 
251
 
 
252
        ids
 
253
            If set, use these instead of automatically generated ids.
 
254
            Must be the same length as the list of files, but may
 
255
            contain None for ids that are to be autogenerated.
 
256
 
 
257
        TODO: Perhaps have an option to add the ids even if the files do
 
258
              not (yet) exist.
 
259
 
 
260
        TODO: Perhaps yield the ids and paths as they're added.
 
261
        """
 
262
        # XXX This should be a WorkingTree method, not a Branch method.
 
263
        raise NotImplementedError('add is abstract')
 
264
 
 
265
    def print_file(self, file, revno):
 
266
        """Print `file` to stdout."""
 
267
        raise NotImplementedError('print_file is abstract')
 
268
 
 
269
    def unknowns(self):
 
270
        """Return all unknown files.
 
271
 
 
272
        These are files in the working directory that are not versioned or
 
273
        control files or ignored.
 
274
        
 
275
        >>> from bzrlib.workingtree import WorkingTree
 
276
        >>> b = ScratchBranch(files=['foo', 'foo~'])
 
277
        >>> map(str, b.unknowns())
 
278
        ['foo']
 
279
        >>> b.add('foo')
 
280
        >>> list(b.unknowns())
 
281
        []
 
282
        >>> WorkingTree(b.base, b).remove('foo')
 
283
        >>> list(b.unknowns())
 
284
        [u'foo']
 
285
        """
 
286
        raise NotImplementedError('unknowns is abstract')
 
287
 
 
288
    def append_revision(self, *revision_ids):
 
289
        raise NotImplementedError('append_revision is abstract')
 
290
 
 
291
    def set_revision_history(self, rev_history):
 
292
        raise NotImplementedError('set_revision_history is abstract')
 
293
 
 
294
    def has_revision(self, revision_id):
 
295
        """True if this branch has a copy of the revision.
 
296
 
 
297
        This does not necessarily imply the revision is merge
 
298
        or on the mainline."""
 
299
        raise NotImplementedError('has_revision is abstract')
 
300
 
 
301
    def get_revision_xml(self, revision_id):
 
302
        raise NotImplementedError('get_revision_xml is abstract')
 
303
 
 
304
    def get_revision(self, revision_id):
 
305
        """Return the Revision object for a named revision"""
 
306
        raise NotImplementedError('get_revision is abstract')
 
307
 
 
308
    def get_revision_delta(self, revno):
 
309
        """Return the delta for one revision.
 
310
 
 
311
        The delta is relative to its mainline predecessor, or the
 
312
        empty tree for revision 1.
 
313
        """
 
314
        assert isinstance(revno, int)
 
315
        rh = self.revision_history()
 
316
        if not (1 <= revno <= len(rh)):
 
317
            raise InvalidRevisionNumber(revno)
 
318
 
 
319
        # revno is 1-based; list is 0-based
 
320
 
 
321
        new_tree = self.revision_tree(rh[revno-1])
 
322
        if revno == 1:
 
323
            old_tree = EmptyTree()
 
324
        else:
 
325
            old_tree = self.revision_tree(rh[revno-2])
 
326
 
 
327
        return compare_trees(old_tree, new_tree)
 
328
 
 
329
    def get_revision_sha1(self, revision_id):
 
330
        """Hash the stored value of a revision, and return it."""
 
331
        raise NotImplementedError('get_revision_sha1 is abstract')
 
332
 
 
333
    def get_ancestry(self, revision_id):
 
334
        """Return a list of revision-ids integrated by a revision.
 
335
        
 
336
        This currently returns a list, but the ordering is not guaranteed:
 
337
        treat it as a set.
 
338
        """
 
339
        raise NotImplementedError('get_ancestry is abstract')
 
340
 
 
341
    def get_inventory(self, revision_id):
 
342
        """Get Inventory object by hash."""
 
343
        raise NotImplementedError('get_inventory is abstract')
 
344
 
 
345
    def get_inventory_xml(self, revision_id):
 
346
        """Get inventory XML as a file object."""
 
347
        raise NotImplementedError('get_inventory_xml is abstract')
 
348
 
 
349
    def get_inventory_sha1(self, revision_id):
 
350
        """Return the sha1 hash of the inventory entry."""
 
351
        raise NotImplementedError('get_inventory_sha1 is abstract')
 
352
 
 
353
    def get_revision_inventory(self, revision_id):
 
354
        """Return inventory of a past revision."""
 
355
        raise NotImplementedError('get_revision_inventory is abstract')
 
356
 
 
357
    def revision_history(self):
 
358
        """Return sequence of revision hashes on to this branch."""
 
359
        raise NotImplementedError('revision_history is abstract')
 
360
 
 
361
    def revno(self):
 
362
        """Return current revision number for this branch.
 
363
 
 
364
        That is equivalent to the number of revisions committed to
 
365
        this branch.
 
366
        """
 
367
        return len(self.revision_history())
 
368
 
 
369
    def last_revision(self):
 
370
        """Return last patch hash, or None if no history."""
 
371
        ph = self.revision_history()
 
372
        if ph:
 
373
            return ph[-1]
 
374
        else:
 
375
            return None
 
376
 
 
377
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
 
378
        """Return a list of new revisions that would perfectly fit.
 
379
        
 
380
        If self and other have not diverged, return a list of the revisions
 
381
        present in other, but missing from self.
 
382
 
 
383
        >>> from bzrlib.commit import commit
 
384
        >>> bzrlib.trace.silent = True
 
385
        >>> br1 = ScratchBranch()
 
386
        >>> br2 = ScratchBranch()
 
387
        >>> br1.missing_revisions(br2)
 
388
        []
 
389
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
390
        >>> br1.missing_revisions(br2)
 
391
        [u'REVISION-ID-1']
 
392
        >>> br2.missing_revisions(br1)
 
393
        []
 
394
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
395
        >>> br1.missing_revisions(br2)
 
396
        []
 
397
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
398
        >>> br1.missing_revisions(br2)
 
399
        [u'REVISION-ID-2A']
 
400
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
401
        >>> br1.missing_revisions(br2)
 
402
        Traceback (most recent call last):
 
403
        DivergedBranches: These branches have diverged.
 
404
        """
 
405
        self_history = self.revision_history()
 
406
        self_len = len(self_history)
 
407
        other_history = other.revision_history()
 
408
        other_len = len(other_history)
 
409
        common_index = min(self_len, other_len) -1
 
410
        if common_index >= 0 and \
 
411
            self_history[common_index] != other_history[common_index]:
 
412
            raise DivergedBranches(self, other)
 
413
 
 
414
        if stop_revision is None:
 
415
            stop_revision = other_len
 
416
        else:
 
417
            assert isinstance(stop_revision, int)
 
418
            if stop_revision > other_len:
 
419
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
 
420
        return other_history[self_len:stop_revision]
 
421
    
 
422
    def update_revisions(self, other, stop_revision=None):
 
423
        """Pull in new perfect-fit revisions."""
 
424
        raise NotImplementedError('update_revisions is abstract')
 
425
 
 
426
    def pullable_revisions(self, other, stop_revision):
 
427
        raise NotImplementedError('pullable_revisions is abstract')
 
428
        
 
429
    def revision_id_to_revno(self, revision_id):
 
430
        """Given a revision id, return its revno"""
 
431
        if revision_id is None:
 
432
            return 0
 
433
        history = self.revision_history()
 
434
        try:
 
435
            return history.index(revision_id) + 1
 
436
        except ValueError:
 
437
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
438
 
 
439
    def get_rev_id(self, revno, history=None):
 
440
        """Find the revision id of the specified revno."""
 
441
        if revno == 0:
 
442
            return None
 
443
        if history is None:
 
444
            history = self.revision_history()
 
445
        elif revno <= 0 or revno > len(history):
 
446
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
447
        return history[revno - 1]
 
448
 
 
449
    def revision_tree(self, revision_id):
 
450
        """Return Tree for a revision on this branch.
 
451
 
 
452
        `revision_id` may be None for the null revision, in which case
 
453
        an `EmptyTree` is returned."""
 
454
        raise NotImplementedError('revision_tree is abstract')
 
455
 
 
456
    def working_tree(self):
 
457
        """Return a `Tree` for the working copy."""
 
458
        raise NotImplementedError('working_tree is abstract')
 
459
 
 
460
    def pull(self, source, overwrite=False):
 
461
        raise NotImplementedError('pull is abstract')
 
462
 
 
463
    def basis_tree(self):
 
464
        """Return `Tree` object for last revision.
 
465
 
 
466
        If there are no revisions yet, return an `EmptyTree`.
 
467
        """
 
468
        return self.revision_tree(self.last_revision())
 
469
 
 
470
    def rename_one(self, from_rel, to_rel):
 
471
        """Rename one file.
 
472
 
 
473
        This can change the directory or the filename or both.
 
474
        """
 
475
        raise NotImplementedError('rename_one is abstract')
 
476
 
 
477
    def move(self, from_paths, to_name):
 
478
        """Rename files.
 
479
 
 
480
        to_name must exist as a versioned directory.
 
481
 
 
482
        If to_name exists and is a directory, the files are moved into
 
483
        it, keeping their old names.  If it is a directory, 
 
484
 
 
485
        Note that to_name is only the last component of the new name;
 
486
        this doesn't change the directory.
 
487
 
 
488
        This returns a list of (from_path, to_path) pairs for each
 
489
        entry that is moved.
 
490
        """
 
491
        raise NotImplementedError('move is abstract')
 
492
 
 
493
    def get_parent(self):
 
494
        """Return the parent location of the branch.
 
495
 
 
496
        This is the default location for push/pull/missing.  The usual
 
497
        pattern is that the user can override it by specifying a
 
498
        location.
 
499
        """
 
500
        raise NotImplementedError('get_parent is abstract')
 
501
 
 
502
    def get_push_location(self):
 
503
        """Return the None or the location to push this branch to."""
 
504
        raise NotImplementedError('get_push_location is abstract')
 
505
 
 
506
    def set_push_location(self, location):
 
507
        """Set a new push location for this branch."""
 
508
        raise NotImplementedError('set_push_location is abstract')
 
509
 
 
510
    def set_parent(self, url):
 
511
        raise NotImplementedError('set_parent is abstract')
 
512
 
 
513
    def check_revno(self, revno):
 
514
        """\
 
515
        Check whether a revno corresponds to any revision.
 
516
        Zero (the NULL revision) is considered valid.
 
517
        """
 
518
        if revno != 0:
 
519
            self.check_real_revno(revno)
 
520
            
 
521
    def check_real_revno(self, revno):
 
522
        """\
 
523
        Check whether a revno corresponds to a real revision.
 
524
        Zero (the NULL revision) is considered invalid
 
525
        """
 
526
        if revno < 1 or revno > self.revno():
 
527
            raise InvalidRevisionNumber(revno)
 
528
        
 
529
    def sign_revision(self, revision_id, gpg_strategy):
 
530
        raise NotImplementedError('sign_revision is abstract')
 
531
 
 
532
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
533
        raise NotImplementedError('store_revision_signature is abstract')
 
534
 
 
535
class BzrBranch(Branch):
 
536
    """A branch stored in the actual filesystem.
 
537
 
 
538
    Note that it's "local" in the context of the filesystem; it doesn't
 
539
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
 
540
    it's writable, and can be accessed via the normal filesystem API.
 
541
 
 
542
    _lock_mode
 
543
        None, or 'r' or 'w'
 
544
 
 
545
    _lock_count
 
546
        If _lock_mode is true, a positive count of the number of times the
 
547
        lock has been taken.
 
548
 
 
549
    _lock
 
550
        Lock object from bzrlib.lock.
 
551
    """
 
552
    # We actually expect this class to be somewhat short-lived; part of its
 
553
    # purpose is to try to isolate what bits of the branch logic are tied to
 
554
    # filesystem access, so that in a later step, we can extricate them to
 
555
    # a separarte ("storage") class.
 
556
    _lock_mode = None
 
557
    _lock_count = None
 
558
    _lock = None
 
559
    _inventory_weave = None
 
560
    
 
561
    # Map some sort of prefix into a namespace
 
562
    # stuff like "revno:10", "revid:", etc.
 
563
    # This should match a prefix with a function which accepts
 
564
    REVISION_NAMESPACES = {}
 
565
 
 
566
    def push_stores(self, branch_to):
 
567
        """See Branch.push_stores."""
 
568
        if (self._branch_format != branch_to._branch_format
 
569
            or self._branch_format != 4):
 
570
            from bzrlib.fetch import greedy_fetch
 
571
            mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
 
572
                   self, self._branch_format, branch_to, branch_to._branch_format)
 
573
            greedy_fetch(to_branch=branch_to, from_branch=self,
 
574
                         revision=self.last_revision())
 
575
            return
 
576
 
 
577
        store_pairs = ((self.text_store,      branch_to.text_store),
 
578
                       (self.inventory_store, branch_to.inventory_store),
 
579
                       (self.revision_store,  branch_to.revision_store))
 
580
        try:
 
581
            for from_store, to_store in store_pairs: 
 
582
                copy_all(from_store, to_store)
 
583
        except UnlistableStore:
 
584
            raise UnlistableBranch(from_store)
 
585
 
 
586
    def __init__(self, transport, init=False,
 
587
                 relax_version_check=False):
 
588
        """Create new branch object at a particular location.
 
589
 
 
590
        transport -- A Transport object, defining how to access files.
 
591
        
 
592
        init -- If True, create new control files in a previously
 
593
             unversioned directory.  If False, the branch must already
 
594
             be versioned.
 
595
 
 
596
        relax_version_check -- If true, the usual check for the branch
 
597
            version is not applied.  This is intended only for
 
598
            upgrade/recovery type use; it's not guaranteed that
 
599
            all operations will work on old format branches.
 
600
 
 
601
        In the test suite, creation of new trees is tested using the
 
602
        `ScratchBranch` class.
 
603
        """
 
604
        assert isinstance(transport, Transport), \
 
605
            "%r is not a Transport" % transport
 
606
        self._transport = transport
 
607
        if init:
 
608
            self._make_control()
 
609
        self._check_format(relax_version_check)
 
610
 
 
611
        def get_store(name, compressed=True, prefixed=False):
 
612
            # FIXME: This approach of assuming stores are all entirely compressed
 
613
            # or entirely uncompressed is tidy, but breaks upgrade from 
 
614
            # some existing branches where there's a mixture; we probably 
 
615
            # still want the option to look for both.
 
616
            relpath = self._rel_controlfilename(name)
 
617
            store = TextStore(self._transport.clone(relpath),
 
618
                              prefixed=prefixed,
 
619
                              compressed=compressed)
 
620
            #if self._transport.should_cache():
 
621
            #    cache_path = os.path.join(self.cache_root, name)
 
622
            #    os.mkdir(cache_path)
 
623
            #    store = bzrlib.store.CachedStore(store, cache_path)
 
624
            return store
 
625
        def get_weave(name, prefixed=False):
 
626
            relpath = self._rel_controlfilename(name)
 
627
            ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
 
628
            if self._transport.should_cache():
 
629
                ws.enable_cache = True
 
630
            return ws
 
631
 
 
632
        if self._branch_format == 4:
 
633
            self.inventory_store = get_store('inventory-store')
 
634
            self.text_store = get_store('text-store')
 
635
            self.revision_store = get_store('revision-store')
 
636
        elif self._branch_format == 5:
 
637
            self.control_weaves = get_weave('')
 
638
            self.weave_store = get_weave('weaves')
 
639
            self.revision_store = get_store('revision-store', compressed=False)
 
640
        elif self._branch_format == 6:
 
641
            self.control_weaves = get_weave('')
 
642
            self.weave_store = get_weave('weaves', prefixed=True)
 
643
            self.revision_store = get_store('revision-store', compressed=False,
 
644
                                            prefixed=True)
 
645
        self.revision_store.register_suffix('sig')
 
646
        self._transaction = None
 
647
 
 
648
    def __str__(self):
 
649
        return '%s(%r)' % (self.__class__.__name__, self._transport.base)
 
650
 
 
651
    __repr__ = __str__
 
652
 
 
653
    def __del__(self):
 
654
        if self._lock_mode or self._lock:
 
655
            # XXX: This should show something every time, and be suitable for
 
656
            # headless operation and embedding
 
657
            warn("branch %r was not explicitly unlocked" % self)
 
658
            self._lock.unlock()
 
659
 
 
660
        # TODO: It might be best to do this somewhere else,
 
661
        # but it is nice for a Branch object to automatically
 
662
        # cache it's information.
 
663
        # Alternatively, we could have the Transport objects cache requests
 
664
        # See the earlier discussion about how major objects (like Branch)
 
665
        # should never expect their __del__ function to run.
 
666
        if hasattr(self, 'cache_root') and self.cache_root is not None:
 
667
            try:
 
668
                shutil.rmtree(self.cache_root)
 
669
            except:
 
670
                pass
 
671
            self.cache_root = None
 
672
 
 
673
    def _get_base(self):
 
674
        if self._transport:
 
675
            return self._transport.base
 
676
        return None
 
677
 
 
678
    base = property(_get_base, doc="The URL for the root of this branch.")
 
679
 
 
680
    def _finish_transaction(self):
 
681
        """Exit the current transaction."""
 
682
        if self._transaction is None:
 
683
            raise errors.LockError('Branch %s is not in a transaction' %
 
684
                                   self)
 
685
        transaction = self._transaction
 
686
        self._transaction = None
 
687
        transaction.finish()
 
688
 
 
689
    def get_transaction(self):
 
690
        """See Branch.get_transaction."""
 
691
        if self._transaction is None:
 
692
            return transactions.PassThroughTransaction()
 
693
        else:
 
694
            return self._transaction
 
695
 
 
696
    def _set_transaction(self, new_transaction):
 
697
        """Set a new active transaction."""
 
698
        if self._transaction is not None:
 
699
            raise errors.LockError('Branch %s is in a transaction already.' %
 
700
                                   self)
 
701
        self._transaction = new_transaction
 
702
 
 
703
    def lock_write(self):
 
704
        mutter("lock write: %s (%s)", self, self._lock_count)
 
705
        # TODO: Upgrade locking to support using a Transport,
 
706
        # and potentially a remote locking protocol
 
707
        if self._lock_mode:
 
708
            if self._lock_mode != 'w':
 
709
                raise LockError("can't upgrade to a write lock from %r" %
 
710
                                self._lock_mode)
 
711
            self._lock_count += 1
 
712
        else:
 
713
            self._lock = self._transport.lock_write(
 
714
                    self._rel_controlfilename('branch-lock'))
 
715
            self._lock_mode = 'w'
 
716
            self._lock_count = 1
 
717
            self._set_transaction(transactions.PassThroughTransaction())
 
718
 
 
719
    def lock_read(self):
 
720
        mutter("lock read: %s (%s)", self, self._lock_count)
 
721
        if self._lock_mode:
 
722
            assert self._lock_mode in ('r', 'w'), \
 
723
                   "invalid lock mode %r" % self._lock_mode
 
724
            self._lock_count += 1
 
725
        else:
 
726
            self._lock = self._transport.lock_read(
 
727
                    self._rel_controlfilename('branch-lock'))
 
728
            self._lock_mode = 'r'
 
729
            self._lock_count = 1
 
730
            self._set_transaction(transactions.ReadOnlyTransaction())
 
731
            # 5K may be excessive, but hey, its a knob.
 
732
            self.get_transaction().set_cache_size(5000)
 
733
                        
 
734
    def unlock(self):
 
735
        mutter("unlock: %s (%s)", self, self._lock_count)
 
736
        if not self._lock_mode:
 
737
            raise LockError('branch %r is not locked' % (self))
 
738
 
 
739
        if self._lock_count > 1:
 
740
            self._lock_count -= 1
 
741
        else:
 
742
            self._finish_transaction()
 
743
            self._lock.unlock()
 
744
            self._lock = None
 
745
            self._lock_mode = self._lock_count = None
 
746
 
 
747
    def abspath(self, name):
 
748
        """See Branch.abspath."""
 
749
        return self._transport.abspath(name)
 
750
 
 
751
    def _rel_controlfilename(self, file_or_path):
 
752
        if not isinstance(file_or_path, basestring):
 
753
            file_or_path = '/'.join(file_or_path)
 
754
        if file_or_path == '':
 
755
            return bzrlib.BZRDIR
 
756
        return bzrlib.transport.urlescape(bzrlib.BZRDIR + '/' + file_or_path)
 
757
 
 
758
    def controlfilename(self, file_or_path):
 
759
        """See Branch.controlfilename."""
 
760
        return self._transport.abspath(self._rel_controlfilename(file_or_path))
 
761
 
 
762
    def controlfile(self, file_or_path, mode='r'):
 
763
        """See Branch.controlfile."""
 
764
        import codecs
 
765
 
 
766
        relpath = self._rel_controlfilename(file_or_path)
 
767
        #TODO: codecs.open() buffers linewise, so it was overloaded with
 
768
        # a much larger buffer, do we need to do the same for getreader/getwriter?
 
769
        if mode == 'rb': 
 
770
            return self._transport.get(relpath)
 
771
        elif mode == 'wb':
 
772
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
 
773
        elif mode == 'r':
 
774
            # XXX: Do we really want errors='replace'?   Perhaps it should be
 
775
            # an error, or at least reported, if there's incorrectly-encoded
 
776
            # data inside a file.
 
777
            # <https://launchpad.net/products/bzr/+bug/3823>
 
778
            return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
 
779
        elif mode == 'w':
 
780
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
 
781
        else:
 
782
            raise BzrError("invalid controlfile mode %r" % mode)
 
783
 
 
784
    def put_controlfile(self, path, f, encode=True):
 
785
        """See Branch.put_controlfile."""
 
786
        self.put_controlfiles([(path, f)], encode=encode)
 
787
 
 
788
    def put_controlfiles(self, files, encode=True):
 
789
        """See Branch.put_controlfiles."""
 
790
        import codecs
 
791
        ctrl_files = []
 
792
        for path, f in files:
 
793
            if encode:
 
794
                if isinstance(f, basestring):
 
795
                    f = f.encode('utf-8', 'replace')
 
796
                else:
 
797
                    f = codecs.getwriter('utf-8')(f, errors='replace')
 
798
            path = self._rel_controlfilename(path)
 
799
            ctrl_files.append((path, f))
 
800
        self._transport.put_multi(ctrl_files)
 
801
 
 
802
    def _make_control(self):
 
803
        from bzrlib.inventory import Inventory
 
804
        from bzrlib.weavefile import write_weave_v5
 
805
        from bzrlib.weave import Weave
 
806
        
 
807
        # Create an empty inventory
 
808
        sio = StringIO()
 
809
        # if we want per-tree root ids then this is the place to set
 
810
        # them; they're not needed for now and so ommitted for
 
811
        # simplicity.
 
812
        bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
 
813
        empty_inv = sio.getvalue()
 
814
        sio = StringIO()
 
815
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
 
816
        empty_weave = sio.getvalue()
 
817
 
 
818
        dirs = [[], 'revision-store', 'weaves']
 
819
        files = [('README', 
 
820
            "This is a Bazaar-NG control directory.\n"
 
821
            "Do not change any files in this directory.\n"),
 
822
            ('branch-format', BZR_BRANCH_FORMAT_6),
 
823
            ('revision-history', ''),
 
824
            ('branch-name', ''),
 
825
            ('branch-lock', ''),
 
826
            ('pending-merges', ''),
 
827
            ('inventory', empty_inv),
 
828
            ('inventory.weave', empty_weave),
 
829
            ('ancestry.weave', empty_weave)
 
830
        ]
 
831
        cfn = self._rel_controlfilename
 
832
        self._transport.mkdir_multi([cfn(d) for d in dirs])
 
833
        self.put_controlfiles(files)
 
834
        mutter('created control directory in ' + self._transport.base)
 
835
 
 
836
    def _check_format(self, relax_version_check):
 
837
        """Check this branch format is supported.
 
838
 
 
839
        The format level is stored, as an integer, in
 
840
        self._branch_format for code that needs to check it later.
 
841
 
 
842
        In the future, we might need different in-memory Branch
 
843
        classes to support downlevel branches.  But not yet.
 
844
        """
 
845
        try:
 
846
            fmt = self.controlfile('branch-format', 'r').read()
 
847
        except NoSuchFile:
 
848
            raise NotBranchError(path=self.base)
 
849
        mutter("got branch format %r", fmt)
 
850
        if fmt == BZR_BRANCH_FORMAT_6:
 
851
            self._branch_format = 6
 
852
        elif fmt == BZR_BRANCH_FORMAT_5:
 
853
            self._branch_format = 5
 
854
        elif fmt == BZR_BRANCH_FORMAT_4:
 
855
            self._branch_format = 4
 
856
 
 
857
        if (not relax_version_check
 
858
            and self._branch_format not in (5, 6)):
 
859
            raise errors.UnsupportedFormatError(
 
860
                           'sorry, branch format %r not supported' % fmt,
 
861
                           ['use a different bzr version',
 
862
                            'or remove the .bzr directory'
 
863
                            ' and "bzr init" again'])
 
864
 
 
865
    def get_root_id(self):
 
866
        """See Branch.get_root_id."""
 
867
        inv = self.get_inventory(self.last_revision())
 
868
        return inv.root.file_id
 
869
 
 
870
    @needs_write_lock
 
871
    def set_root_id(self, file_id):
 
872
        """See Branch.set_root_id."""
 
873
        inv = self.working_tree().read_working_inventory()
 
874
        orig_root_id = inv.root.file_id
 
875
        del inv._byid[inv.root.file_id]
 
876
        inv.root.file_id = file_id
 
877
        inv._byid[inv.root.file_id] = inv.root
 
878
        for fid in inv:
 
879
            entry = inv[fid]
 
880
            if entry.parent_id in (None, orig_root_id):
 
881
                entry.parent_id = inv.root.file_id
 
882
        self._write_inventory(inv)
 
883
 
 
884
    @needs_write_lock
 
885
    def add(self, files, ids=None):
 
886
        """See Branch.add."""
 
887
        # TODO: Re-adding a file that is removed in the working copy
 
888
        # should probably put it back with the previous ID.
 
889
        if isinstance(files, basestring):
 
890
            assert(ids is None or isinstance(ids, basestring))
 
891
            files = [files]
 
892
            if ids is not None:
 
893
                ids = [ids]
 
894
 
 
895
        if ids is None:
 
896
            ids = [None] * len(files)
 
897
        else:
 
898
            assert(len(ids) == len(files))
 
899
 
 
900
        inv = self.working_tree().read_working_inventory()
 
901
        for f,file_id in zip(files, ids):
 
902
            if is_control_file(f):
 
903
                raise BzrError("cannot add control file %s" % quotefn(f))
 
904
 
 
905
            fp = splitpath(f)
 
906
 
 
907
            if len(fp) == 0:
 
908
                raise BzrError("cannot add top-level %r" % f)
 
909
 
 
910
            fullpath = os.path.normpath(self.abspath(f))
 
911
 
 
912
            try:
 
913
                kind = file_kind(fullpath)
 
914
            except OSError:
 
915
                # maybe something better?
 
916
                raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
 
917
 
 
918
            if not InventoryEntry.versionable_kind(kind):
 
919
                raise BzrError('cannot add: not a versionable file ('
 
920
                               'i.e. regular file, symlink or directory): %s' % quotefn(f))
 
921
 
 
922
            if file_id is None:
 
923
                file_id = gen_file_id(f)
 
924
            inv.add_path(f, kind=kind, file_id=file_id)
 
925
 
 
926
            mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
 
927
 
 
928
        self.working_tree()._write_inventory(inv)
 
929
 
 
930
    @needs_read_lock
 
931
    def print_file(self, file, revno):
 
932
        """See Branch.print_file."""
 
933
        tree = self.revision_tree(self.get_rev_id(revno))
 
934
        # use inventory as it was in that revision
 
935
        file_id = tree.inventory.path2id(file)
 
936
        if not file_id:
 
937
            raise BzrError("%r is not present in revision %s" % (file, revno))
 
938
        tree.print_file(file_id)
 
939
 
 
940
    def unknowns(self):
 
941
        """See Branch.unknowns."""
 
942
        return self.working_tree().unknowns()
 
943
 
 
944
    @needs_write_lock
 
945
    def append_revision(self, *revision_ids):
 
946
        """See Branch.append_revision."""
 
947
        for revision_id in revision_ids:
 
948
            mutter("add {%s} to revision-history" % revision_id)
 
949
        rev_history = self.revision_history()
 
950
        rev_history.extend(revision_ids)
 
951
        self.set_revision_history(rev_history)
 
952
 
 
953
    @needs_write_lock
 
954
    def set_revision_history(self, rev_history):
 
955
        """See Branch.set_revision_history."""
 
956
        self.put_controlfile('revision-history', '\n'.join(rev_history))
 
957
 
 
958
    def has_revision(self, revision_id):
 
959
        """See Branch.has_revision."""
 
960
        return (revision_id is None
 
961
                or self.revision_store.has_id(revision_id))
 
962
 
 
963
    @needs_read_lock
 
964
    def _get_revision_xml_file(self, revision_id):
 
965
        if not revision_id or not isinstance(revision_id, basestring):
 
966
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
 
967
        try:
 
968
            return self.revision_store.get(revision_id)
 
969
        except (IndexError, KeyError):
 
970
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
971
 
 
972
    def get_revision_xml(self, revision_id):
 
973
        """See Branch.get_revision_xml."""
 
974
        return self._get_revision_xml_file(revision_id).read()
 
975
 
 
976
    def get_revision(self, revision_id):
 
977
        """See Branch.get_revision."""
 
978
        xml_file = self._get_revision_xml_file(revision_id)
 
979
 
 
980
        try:
 
981
            r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
 
982
        except SyntaxError, e:
 
983
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
 
984
                                         [revision_id,
 
985
                                          str(e)])
 
986
            
 
987
        assert r.revision_id == revision_id
 
988
        return r
 
989
 
 
990
    def get_revision_sha1(self, revision_id):
 
991
        """See Branch.get_revision_sha1."""
 
992
        # In the future, revision entries will be signed. At that
 
993
        # point, it is probably best *not* to include the signature
 
994
        # in the revision hash. Because that lets you re-sign
 
995
        # the revision, (add signatures/remove signatures) and still
 
996
        # have all hash pointers stay consistent.
 
997
        # But for now, just hash the contents.
 
998
        return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
 
999
 
 
1000
    def get_ancestry(self, revision_id):
 
1001
        """See Branch.get_ancestry."""
 
1002
        if revision_id is None:
 
1003
            return [None]
 
1004
        w = self._get_inventory_weave()
 
1005
        return [None] + map(w.idx_to_name,
 
1006
                            w.inclusions([w.lookup(revision_id)]))
 
1007
 
 
1008
    def _get_inventory_weave(self):
 
1009
        return self.control_weaves.get_weave('inventory',
 
1010
                                             self.get_transaction())
 
1011
 
 
1012
    def get_inventory(self, revision_id):
 
1013
        """See Branch.get_inventory."""
 
1014
        xml = self.get_inventory_xml(revision_id)
 
1015
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
1016
 
 
1017
    def get_inventory_xml(self, revision_id):
 
1018
        """See Branch.get_inventory_xml."""
 
1019
        try:
 
1020
            assert isinstance(revision_id, basestring), type(revision_id)
 
1021
            iw = self._get_inventory_weave()
 
1022
            return iw.get_text(iw.lookup(revision_id))
 
1023
        except IndexError:
 
1024
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
 
1025
 
 
1026
    def get_inventory_sha1(self, revision_id):
 
1027
        """See Branch.get_inventory_sha1."""
 
1028
        return self.get_revision(revision_id).inventory_sha1
 
1029
 
 
1030
    def get_revision_inventory(self, revision_id):
 
1031
        """See Branch.get_revision_inventory."""
 
1032
        # TODO: Unify this with get_inventory()
 
1033
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
1034
        # must be the same as its revision, so this is trivial.
 
1035
        if revision_id == None:
 
1036
            # This does not make sense: if there is no revision,
 
1037
            # then it is the current tree inventory surely ?!
 
1038
            # and thus get_root_id() is something that looks at the last
 
1039
            # commit on the branch, and the get_root_id is an inventory check.
 
1040
            raise NotImplementedError
 
1041
            # return Inventory(self.get_root_id())
 
1042
        else:
 
1043
            return self.get_inventory(revision_id)
 
1044
 
 
1045
    @needs_read_lock
 
1046
    def revision_history(self):
 
1047
        """See Branch.revision_history."""
 
1048
        transaction = self.get_transaction()
 
1049
        history = transaction.map.find_revision_history()
 
1050
        if history is not None:
 
1051
            mutter("cache hit for revision-history in %s", self)
 
1052
            return list(history)
 
1053
        history = [l.rstrip('\r\n') for l in
 
1054
                self.controlfile('revision-history', 'r').readlines()]
 
1055
        transaction.map.add_revision_history(history)
 
1056
        # this call is disabled because revision_history is 
 
1057
        # not really an object yet, and the transaction is for objects.
 
1058
        # transaction.register_clean(history, precious=True)
 
1059
        return list(history)
 
1060
 
 
1061
    def update_revisions(self, other, stop_revision=None):
 
1062
        """See Branch.update_revisions."""
 
1063
        from bzrlib.fetch import greedy_fetch
 
1064
        if stop_revision is None:
 
1065
            stop_revision = other.last_revision()
 
1066
        ### Should this be checking is_ancestor instead of revision_history?
 
1067
        if (stop_revision is not None and 
 
1068
            stop_revision in self.revision_history()):
 
1069
            return
 
1070
        greedy_fetch(to_branch=self, from_branch=other,
 
1071
                     revision=stop_revision)
 
1072
        pullable_revs = self.pullable_revisions(other, stop_revision)
 
1073
        if len(pullable_revs) > 0:
 
1074
            self.append_revision(*pullable_revs)
 
1075
 
 
1076
    def pullable_revisions(self, other, stop_revision):
 
1077
        """See Branch.pullable_revisions."""
 
1078
        other_revno = other.revision_id_to_revno(stop_revision)
 
1079
        try:
 
1080
            return self.missing_revisions(other, other_revno)
 
1081
        except DivergedBranches, e:
 
1082
            try:
 
1083
                pullable_revs = get_intervening_revisions(self.last_revision(),
 
1084
                                                          stop_revision, self)
 
1085
                assert self.last_revision() not in pullable_revs
 
1086
                return pullable_revs
 
1087
            except bzrlib.errors.NotAncestor:
 
1088
                if is_ancestor(self.last_revision(), stop_revision, self):
 
1089
                    return []
 
1090
                else:
 
1091
                    raise e
 
1092
        
 
1093
    def revision_tree(self, revision_id):
 
1094
        """See Branch.revision_tree."""
 
1095
        # TODO: refactor this to use an existing revision object
 
1096
        # so we don't need to read it in twice.
 
1097
        if revision_id == None or revision_id == NULL_REVISION:
 
1098
            return EmptyTree()
 
1099
        else:
 
1100
            inv = self.get_revision_inventory(revision_id)
 
1101
            return RevisionTree(self.weave_store, inv, revision_id)
 
1102
 
 
1103
    def working_tree(self):
 
1104
        """See Branch.working_tree."""
 
1105
        from bzrlib.workingtree import WorkingTree
 
1106
        # TODO: In the future, perhaps WorkingTree should utilize Transport
 
1107
        # RobertCollins 20051003 - I don't think it should - working trees are
 
1108
        # much more complex to keep consistent than our careful .bzr subset.
 
1109
        # instead, we should say that working trees are local only, and optimise
 
1110
        # for that.
 
1111
        if self._transport.base.find('://') != -1:
 
1112
            raise NoWorkingTree(self.base)
 
1113
        return WorkingTree(self.base, branch=self)
 
1114
 
 
1115
    @needs_write_lock
 
1116
    def pull(self, source, overwrite=False):
 
1117
        """See Branch.pull."""
 
1118
        source.lock_read()
 
1119
        try:
 
1120
            try:
 
1121
                self.update_revisions(source)
 
1122
            except DivergedBranches:
 
1123
                if not overwrite:
 
1124
                    raise
 
1125
                self.set_revision_history(source.revision_history())
 
1126
        finally:
 
1127
            source.unlock()
 
1128
 
 
1129
    @needs_write_lock
 
1130
    def rename_one(self, from_rel, to_rel):
 
1131
        """See Branch.rename_one."""
 
1132
        tree = self.working_tree()
 
1133
        inv = tree.inventory
 
1134
        if not tree.has_filename(from_rel):
 
1135
            raise BzrError("can't rename: old working file %r does not exist" % from_rel)
 
1136
        if tree.has_filename(to_rel):
 
1137
            raise BzrError("can't rename: new working file %r already exists" % to_rel)
 
1138
 
 
1139
        file_id = inv.path2id(from_rel)
 
1140
        if file_id == None:
 
1141
            raise BzrError("can't rename: old name %r is not versioned" % from_rel)
 
1142
 
 
1143
        if inv.path2id(to_rel):
 
1144
            raise BzrError("can't rename: new name %r is already versioned" % to_rel)
 
1145
 
 
1146
        to_dir, to_tail = os.path.split(to_rel)
 
1147
        to_dir_id = inv.path2id(to_dir)
 
1148
        if to_dir_id == None and to_dir != '':
 
1149
            raise BzrError("can't determine destination directory id for %r" % to_dir)
 
1150
 
 
1151
        mutter("rename_one:")
 
1152
        mutter("  file_id    {%s}" % file_id)
 
1153
        mutter("  from_rel   %r" % from_rel)
 
1154
        mutter("  to_rel     %r" % to_rel)
 
1155
        mutter("  to_dir     %r" % to_dir)
 
1156
        mutter("  to_dir_id  {%s}" % to_dir_id)
 
1157
 
 
1158
        inv.rename(file_id, to_dir_id, to_tail)
 
1159
 
 
1160
        from_abs = self.abspath(from_rel)
 
1161
        to_abs = self.abspath(to_rel)
 
1162
        try:
 
1163
            rename(from_abs, to_abs)
 
1164
        except OSError, e:
 
1165
            raise BzrError("failed to rename %r to %r: %s"
 
1166
                    % (from_abs, to_abs, e[1]),
 
1167
                    ["rename rolled back"])
 
1168
 
 
1169
        self.working_tree()._write_inventory(inv)
 
1170
 
 
1171
    @needs_write_lock
 
1172
    def move(self, from_paths, to_name):
 
1173
        """See Branch.move."""
 
1174
        result = []
 
1175
        ## TODO: Option to move IDs only
 
1176
        assert not isinstance(from_paths, basestring)
 
1177
        tree = self.working_tree()
 
1178
        inv = tree.inventory
 
1179
        to_abs = self.abspath(to_name)
 
1180
        if not isdir(to_abs):
 
1181
            raise BzrError("destination %r is not a directory" % to_abs)
 
1182
        if not tree.has_filename(to_name):
 
1183
            raise BzrError("destination %r not in working directory" % to_abs)
 
1184
        to_dir_id = inv.path2id(to_name)
 
1185
        if to_dir_id == None and to_name != '':
 
1186
            raise BzrError("destination %r is not a versioned directory" % to_name)
 
1187
        to_dir_ie = inv[to_dir_id]
 
1188
        if to_dir_ie.kind not in ('directory', 'root_directory'):
 
1189
            raise BzrError("destination %r is not a directory" % to_abs)
 
1190
 
 
1191
        to_idpath = inv.get_idpath(to_dir_id)
 
1192
 
 
1193
        for f in from_paths:
 
1194
            if not tree.has_filename(f):
 
1195
                raise BzrError("%r does not exist in working tree" % f)
 
1196
            f_id = inv.path2id(f)
 
1197
            if f_id == None:
 
1198
                raise BzrError("%r is not versioned" % f)
 
1199
            name_tail = splitpath(f)[-1]
 
1200
            dest_path = appendpath(to_name, name_tail)
 
1201
            if tree.has_filename(dest_path):
 
1202
                raise BzrError("destination %r already exists" % dest_path)
 
1203
            if f_id in to_idpath:
 
1204
                raise BzrError("can't move %r to a subdirectory of itself" % f)
 
1205
 
 
1206
        # OK, so there's a race here, it's possible that someone will
 
1207
        # create a file in this interval and then the rename might be
 
1208
        # left half-done.  But we should have caught most problems.
 
1209
 
 
1210
        for f in from_paths:
 
1211
            name_tail = splitpath(f)[-1]
 
1212
            dest_path = appendpath(to_name, name_tail)
 
1213
            result.append((f, dest_path))
 
1214
            inv.rename(inv.path2id(f), to_dir_id, name_tail)
 
1215
            try:
 
1216
                rename(self.abspath(f), self.abspath(dest_path))
 
1217
            except OSError, e:
 
1218
                raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
 
1219
                        ["rename rolled back"])
 
1220
 
 
1221
        self.working_tree()._write_inventory(inv)
 
1222
        return result
 
1223
 
 
1224
    def get_parent(self):
 
1225
        """See Branch.get_parent."""
 
1226
        import errno
 
1227
        _locs = ['parent', 'pull', 'x-pull']
 
1228
        for l in _locs:
 
1229
            try:
 
1230
                return self.controlfile(l, 'r').read().strip('\n')
 
1231
            except IOError, e:
 
1232
                if e.errno != errno.ENOENT:
 
1233
                    raise
 
1234
        return None
 
1235
 
 
1236
    def get_push_location(self):
 
1237
        """See Branch.get_push_location."""
 
1238
        config = bzrlib.config.BranchConfig(self)
 
1239
        push_loc = config.get_user_option('push_location')
 
1240
        return push_loc
 
1241
 
 
1242
    def set_push_location(self, location):
 
1243
        """See Branch.set_push_location."""
 
1244
        config = bzrlib.config.LocationConfig(self.base)
 
1245
        config.set_user_option('push_location', location)
 
1246
 
 
1247
    @needs_write_lock
 
1248
    def set_parent(self, url):
 
1249
        """See Branch.set_parent."""
 
1250
        # TODO: Maybe delete old location files?
 
1251
        from bzrlib.atomicfile import AtomicFile
 
1252
        f = AtomicFile(self.controlfilename('parent'))
 
1253
        try:
 
1254
            f.write(url + '\n')
 
1255
            f.commit()
 
1256
        finally:
 
1257
            f.close()
 
1258
 
 
1259
    def tree_config(self):
 
1260
        return TreeConfig(self)
 
1261
 
 
1262
    def sign_revision(self, revision_id, gpg_strategy):
 
1263
        """See Branch.sign_revision."""
 
1264
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
 
1265
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
 
1266
 
 
1267
    @needs_write_lock
 
1268
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
1269
        """See Branch.store_revision_signature."""
 
1270
        self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)), 
 
1271
                                revision_id, "sig")
 
1272
 
 
1273
 
 
1274
class ScratchBranch(BzrBranch):
 
1275
    """Special test class: a branch that cleans up after itself.
 
1276
 
 
1277
    >>> b = ScratchBranch()
 
1278
    >>> isdir(b.base)
 
1279
    True
 
1280
    >>> bd = b.base
 
1281
    >>> b._transport.__del__()
 
1282
    >>> isdir(bd)
 
1283
    False
 
1284
    """
 
1285
 
 
1286
    def __init__(self, files=[], dirs=[], transport=None):
 
1287
        """Make a test branch.
 
1288
 
 
1289
        This creates a temporary directory and runs init-tree in it.
 
1290
 
 
1291
        If any files are listed, they are created in the working copy.
 
1292
        """
 
1293
        if transport is None:
 
1294
            transport = bzrlib.transport.local.ScratchTransport()
 
1295
            super(ScratchBranch, self).__init__(transport, init=True)
 
1296
        else:
 
1297
            super(ScratchBranch, self).__init__(transport)
 
1298
 
 
1299
        for d in dirs:
 
1300
            self._transport.mkdir(d)
 
1301
            
 
1302
        for f in files:
 
1303
            self._transport.put(f, 'content of %s' % f)
 
1304
 
 
1305
 
 
1306
    def clone(self):
 
1307
        """
 
1308
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
1309
        >>> clone = orig.clone()
 
1310
        >>> if os.name != 'nt':
 
1311
        ...   os.path.samefile(orig.base, clone.base)
 
1312
        ... else:
 
1313
        ...   orig.base == clone.base
 
1314
        ...
 
1315
        False
 
1316
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
1317
        True
 
1318
        """
 
1319
        from shutil import copytree
 
1320
        from tempfile import mkdtemp
 
1321
        base = mkdtemp()
 
1322
        os.rmdir(base)
 
1323
        copytree(self.base, base, symlinks=True)
 
1324
        return ScratchBranch(
 
1325
            transport=bzrlib.transport.local.ScratchTransport(base))
 
1326
    
 
1327
 
 
1328
######################################################################
 
1329
# predicates
 
1330
 
 
1331
 
 
1332
def is_control_file(filename):
 
1333
    ## FIXME: better check
 
1334
    filename = os.path.normpath(filename)
 
1335
    while filename != '':
 
1336
        head, tail = os.path.split(filename)
 
1337
        ## mutter('check %r for control file' % ((head, tail), ))
 
1338
        if tail == bzrlib.BZRDIR:
 
1339
            return True
 
1340
        if filename == head:
 
1341
            break
 
1342
        filename = head
 
1343
    return False
 
1344
 
 
1345
 
 
1346
 
 
1347
def gen_file_id(name):
 
1348
    """Return new file id.
 
1349
 
 
1350
    This should probably generate proper UUIDs, but for the moment we
 
1351
    cope with just randomness because running uuidgen every time is
 
1352
    slow."""
 
1353
    import re
 
1354
    from binascii import hexlify
 
1355
    from time import time
 
1356
 
 
1357
    # get last component
 
1358
    idx = name.rfind('/')
 
1359
    if idx != -1:
 
1360
        name = name[idx+1 : ]
 
1361
    idx = name.rfind('\\')
 
1362
    if idx != -1:
 
1363
        name = name[idx+1 : ]
 
1364
 
 
1365
    # make it not a hidden file
 
1366
    name = name.lstrip('.')
 
1367
 
 
1368
    # remove any wierd characters; we don't escape them but rather
 
1369
    # just pull them out
 
1370
    name = re.sub(r'[^\w.]', '', name)
 
1371
 
 
1372
    s = hexlify(rand_bytes(8))
 
1373
    return '-'.join((name, compact_date(time()), s))
 
1374
 
 
1375
 
 
1376
def gen_root_id():
 
1377
    """Return a new tree-root file id."""
 
1378
    return gen_file_id('TREE_ROOT')
 
1379
 
 
1380