~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-07-06 03:15:29 UTC
  • mfrom: (1711.2.78 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060706031529-e189d8c3f42076be
(jam) allow plugins to include benchmarks

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
 
18
from copy import deepcopy
18
19
from cStringIO import StringIO
19
 
 
20
 
from bzrlib.lazy_import import lazy_import
21
 
lazy_import(globals(), """
 
20
from unittest import TestSuite
22
21
from warnings import warn
23
22
 
24
23
import bzrlib
25
 
from bzrlib import (
26
 
        bzrdir,
27
 
        cache_utf8,
28
 
        config as _mod_config,
29
 
        errors,
30
 
        lockdir,
31
 
        lockable_files,
32
 
        osutils,
33
 
        revision as _mod_revision,
34
 
        transport,
35
 
        tree,
36
 
        tsort,
37
 
        ui,
38
 
        urlutils,
39
 
        )
40
 
from bzrlib.config import BranchConfig, TreeConfig
41
 
from bzrlib.lockable_files import LockableFiles, TransportLock
42
 
from bzrlib.tag import (
43
 
    BasicTags,
44
 
    DisabledTags,
45
 
    )
46
 
""")
47
 
 
 
24
from bzrlib import bzrdir, errors, lockdir, osutils, revision, \
 
25
        tree, \
 
26
        ui, \
 
27
        urlutils
 
28
from bzrlib.config import TreeConfig
48
29
from bzrlib.decorators import needs_read_lock, needs_write_lock
49
 
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
50
 
                           HistoryMissing, InvalidRevisionId,
51
 
                           InvalidRevisionNumber, LockError, NoSuchFile,
 
30
import bzrlib.errors as errors
 
31
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches, 
 
32
                           HistoryMissing, InvalidRevisionId, 
 
33
                           InvalidRevisionNumber, LockError, NoSuchFile, 
52
34
                           NoSuchRevision, NoWorkingTree, NotVersionedError,
53
 
                           NotBranchError, UninitializableFormat,
54
 
                           UnlistableStore, UnlistableBranch,
 
35
                           NotBranchError, UninitializableFormat, 
 
36
                           UnlistableStore, UnlistableBranch, 
55
37
                           )
56
 
from bzrlib.hooks import Hooks
 
38
from bzrlib.lockable_files import LockableFiles, TransportLock
57
39
from bzrlib.symbol_versioning import (deprecated_function,
58
40
                                      deprecated_method,
59
41
                                      DEPRECATED_PARAMETER,
60
42
                                      deprecated_passed,
61
 
                                      zero_eight, zero_nine, zero_sixteen,
 
43
                                      zero_eight, zero_nine,
62
44
                                      )
63
45
from bzrlib.trace import mutter, note
64
46
 
65
47
 
66
48
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
67
49
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
68
 
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
 
50
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
69
51
 
70
52
 
71
53
# TODO: Maybe include checks for common corruption of newlines, etc?
85
67
 
86
68
    base
87
69
        Base directory/url of the branch.
88
 
 
89
 
    hooks: An instance of BranchHooks.
90
70
    """
91
71
    # this is really an instance variable - FIXME move it there
92
72
    # - RBC 20060112
93
73
    base = None
94
74
 
95
 
    # override this to set the strategy for storing tags
96
 
    def _make_tags(self):
97
 
        return DisabledTags(self)
98
 
 
99
75
    def __init__(self, *ignored, **ignored_too):
100
 
        self.tags = self._make_tags()
101
 
        self._revision_history_cache = None
102
 
        self._revision_id_to_revno_cache = None
 
76
        raise NotImplementedError('The Branch class is abstract')
103
77
 
104
78
    def break_lock(self):
105
79
        """Break a lock if one is present from another instance.
120
94
    def open_downlevel(base):
121
95
        """Open a branch which may be of an old format."""
122
96
        return Branch.open(base, _unsupported=True)
123
 
 
 
97
        
124
98
    @staticmethod
125
99
    def open(base, _unsupported=False):
126
100
        """Open the branch rooted at base.
132
106
        return control.open_branch(_unsupported)
133
107
 
134
108
    @staticmethod
135
 
    def open_from_transport(transport, _unsupported=False):
136
 
        """Open the branch rooted at transport"""
137
 
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
138
 
        return control.open_branch(_unsupported)
139
 
 
140
 
    @staticmethod
141
 
    def open_containing(url, possible_transports=None):
 
109
    def open_containing(url):
142
110
        """Open an existing branch which contains url.
143
111
        
144
112
        This probes for a branch at url, and searches upwards from there.
149
117
        format, UnknownFormatError or UnsupportedFormatError are raised.
150
118
        If there is one, it is returned, along with the unused portion of url.
151
119
        """
152
 
        control, relpath = bzrdir.BzrDir.open_containing(url,
153
 
                                                         possible_transports)
 
120
        control, relpath = bzrdir.BzrDir.open_containing(url)
154
121
        return control.open_branch(), relpath
155
122
 
156
123
    @staticmethod
163
130
        """
164
131
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
165
132
 
166
 
    @deprecated_function(zero_eight)
167
133
    def setup_caching(self, cache_root):
168
134
        """Subclasses that care about caching should override this, and set
169
135
        up cached stores located under cache_root.
170
 
        
171
 
        NOTE: This is unused.
172
136
        """
173
 
        pass
 
137
        # seems to be unused, 2006-01-13 mbp
 
138
        warn('%s is deprecated' % self.setup_caching)
 
139
        self.cache_root = cache_root
174
140
 
175
141
    def get_config(self):
176
 
        return BranchConfig(self)
 
142
        return bzrlib.config.BranchConfig(self)
177
143
 
178
144
    def _get_nick(self):
179
145
        return self.get_config().get_nickname()
180
146
 
181
147
    def _set_nick(self, nick):
182
 
        self.get_config().set_user_option('nickname', nick, warn_masked=True)
 
148
        self.get_config().set_user_option('nickname', nick)
183
149
 
184
150
    nick = property(_get_nick, _set_nick)
185
151
 
186
152
    def is_locked(self):
187
 
        raise NotImplementedError(self.is_locked)
 
153
        raise NotImplementedError('is_locked is abstract')
188
154
 
189
155
    def lock_write(self):
190
 
        raise NotImplementedError(self.lock_write)
 
156
        raise NotImplementedError('lock_write is abstract')
191
157
 
192
158
    def lock_read(self):
193
 
        raise NotImplementedError(self.lock_read)
 
159
        raise NotImplementedError('lock_read is abstract')
194
160
 
195
161
    def unlock(self):
196
 
        raise NotImplementedError(self.unlock)
 
162
        raise NotImplementedError('unlock is abstract')
197
163
 
198
164
    def peek_lock_mode(self):
199
165
        """Return lock mode for the Branch: 'r', 'w' or None"""
200
166
        raise NotImplementedError(self.peek_lock_mode)
201
167
 
202
168
    def get_physical_lock_status(self):
203
 
        raise NotImplementedError(self.get_physical_lock_status)
204
 
 
205
 
    @needs_read_lock
206
 
    def get_revision_id_to_revno_map(self):
207
 
        """Return the revision_id => dotted revno map.
208
 
 
209
 
        This will be regenerated on demand, but will be cached.
210
 
 
211
 
        :return: A dictionary mapping revision_id => dotted revno.
212
 
            This dictionary should not be modified by the caller.
213
 
        """
214
 
        if self._revision_id_to_revno_cache is not None:
215
 
            mapping = self._revision_id_to_revno_cache
216
 
        else:
217
 
            mapping = self._gen_revno_map()
218
 
            self._cache_revision_id_to_revno(mapping)
219
 
        # TODO: jam 20070417 Since this is being cached, should we be returning
220
 
        #       a copy?
221
 
        # I would rather not, and instead just declare that users should not
222
 
        # modify the return value.
223
 
        return mapping
224
 
 
225
 
    def _gen_revno_map(self):
226
 
        """Create a new mapping from revision ids to dotted revnos.
227
 
 
228
 
        Dotted revnos are generated based on the current tip in the revision
229
 
        history.
230
 
        This is the worker function for get_revision_id_to_revno_map, which
231
 
        just caches the return value.
232
 
 
233
 
        :return: A dictionary mapping revision_id => dotted revno.
234
 
        """
235
 
        last_revision = self.last_revision()
236
 
        revision_graph = self.repository.get_revision_graph(last_revision)
237
 
        merge_sorted_revisions = tsort.merge_sort(
238
 
            revision_graph,
239
 
            last_revision,
240
 
            None,
241
 
            generate_revno=True)
242
 
        revision_id_to_revno = dict((rev_id, revno)
243
 
                                    for seq_num, rev_id, depth, revno, end_of_merge
244
 
                                     in merge_sorted_revisions)
245
 
        return revision_id_to_revno
246
 
 
247
 
    def leave_lock_in_place(self):
248
 
        """Tell this branch object not to release the physical lock when this
249
 
        object is unlocked.
250
 
        
251
 
        If lock_write doesn't return a token, then this method is not supported.
252
 
        """
253
 
        self.control_files.leave_in_place()
254
 
 
255
 
    def dont_leave_lock_in_place(self):
256
 
        """Tell this branch object to release the physical lock when this
257
 
        object is unlocked, even if it didn't originally acquire it.
258
 
 
259
 
        If lock_write doesn't return a token, then this method is not supported.
260
 
        """
261
 
        self.control_files.dont_leave_in_place()
 
169
        raise NotImplementedError('get_physical_lock_status is abstract')
262
170
 
263
171
    def abspath(self, name):
264
172
        """Return absolute filename for something in the branch
266
174
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
267
175
        method and not a tree method.
268
176
        """
269
 
        raise NotImplementedError(self.abspath)
 
177
        raise NotImplementedError('abspath is abstract')
270
178
 
271
179
    def bind(self, other):
272
180
        """Bind the local branch the other branch.
300
208
        try:
301
209
            if last_revision is None:
302
210
                pb.update('get source history')
303
 
                last_revision = from_branch.last_revision()
304
 
                if last_revision is None:
305
 
                    last_revision = _mod_revision.NULL_REVISION
 
211
                from_history = from_branch.revision_history()
 
212
                if from_history:
 
213
                    last_revision = from_history[-1]
 
214
                else:
 
215
                    # no history in the source branch
 
216
                    last_revision = revision.NULL_REVISION
306
217
            return self.repository.fetch(from_branch.repository,
307
218
                                         revision_id=last_revision,
308
219
                                         pb=nested_pb)
319
230
        """
320
231
        return None
321
232
    
322
 
    def get_old_bound_location(self):
323
 
        """Return the URL of the branch we used to be bound to
324
 
        """
325
 
        raise errors.UpgradeRequired(self.base)
326
 
 
327
233
    def get_commit_builder(self, parents, config=None, timestamp=None, 
328
234
                           timezone=None, committer=None, revprops=None, 
329
235
                           revision_id=None):
341
247
        if config is None:
342
248
            config = self.get_config()
343
249
        
344
 
        return self.repository.get_commit_builder(self, parents, config,
 
250
        return self.repository.get_commit_builder(self, parents, config, 
345
251
            timestamp, timezone, committer, revprops, revision_id)
346
252
 
347
253
    def get_master_branch(self):
363
269
            raise InvalidRevisionNumber(revno)
364
270
        return self.repository.get_revision_delta(rh[revno-1])
365
271
 
366
 
    @deprecated_method(zero_sixteen)
367
272
    def get_root_id(self):
368
 
        """Return the id of this branches root
369
 
 
370
 
        Deprecated: branches don't have root ids-- trees do.
371
 
        Use basis_tree().get_root_id() instead.
372
 
        """
373
 
        raise NotImplementedError(self.get_root_id)
 
273
        """Return the id of this branches root"""
 
274
        raise NotImplementedError('get_root_id is abstract')
374
275
 
375
276
    def print_file(self, file, revision_id):
376
277
        """Print `file` to stdout."""
377
 
        raise NotImplementedError(self.print_file)
 
278
        raise NotImplementedError('print_file is abstract')
378
279
 
379
280
    def append_revision(self, *revision_ids):
380
 
        raise NotImplementedError(self.append_revision)
 
281
        raise NotImplementedError('append_revision is abstract')
381
282
 
382
283
    def set_revision_history(self, rev_history):
383
 
        raise NotImplementedError(self.set_revision_history)
384
 
 
385
 
    def _cache_revision_history(self, rev_history):
386
 
        """Set the cached revision history to rev_history.
387
 
 
388
 
        The revision_history method will use this cache to avoid regenerating
389
 
        the revision history.
390
 
 
391
 
        This API is semi-public; it only for use by subclasses, all other code
392
 
        should consider it to be private.
393
 
        """
394
 
        self._revision_history_cache = rev_history
395
 
 
396
 
    def _cache_revision_id_to_revno(self, revision_id_to_revno):
397
 
        """Set the cached revision_id => revno map to revision_id_to_revno.
398
 
 
399
 
        This API is semi-public; it only for use by subclasses, all other code
400
 
        should consider it to be private.
401
 
        """
402
 
        self._revision_id_to_revno_cache = revision_id_to_revno
403
 
 
404
 
    def _clear_cached_state(self):
405
 
        """Clear any cached data on this branch, e.g. cached revision history.
406
 
 
407
 
        This means the next call to revision_history will need to call
408
 
        _gen_revision_history.
409
 
 
410
 
        This API is semi-public; it only for use by subclasses, all other code
411
 
        should consider it to be private.
412
 
        """
413
 
        self._revision_history_cache = None
414
 
        self._revision_id_to_revno_cache = None
415
 
 
416
 
    def _gen_revision_history(self):
417
 
        """Return sequence of revision hashes on to this branch.
418
 
        
419
 
        Unlike revision_history, this method always regenerates or rereads the
420
 
        revision history, i.e. it does not cache the result, so repeated calls
421
 
        may be expensive.
422
 
 
423
 
        Concrete subclasses should override this instead of revision_history so
424
 
        that subclasses do not need to deal with caching logic.
425
 
        
426
 
        This API is semi-public; it only for use by subclasses, all other code
427
 
        should consider it to be private.
428
 
        """
429
 
        raise NotImplementedError(self._gen_revision_history)
430
 
 
431
 
    @needs_read_lock
 
284
        raise NotImplementedError('set_revision_history is abstract')
 
285
 
432
286
    def revision_history(self):
433
 
        """Return sequence of revision hashes on to this branch.
434
 
        
435
 
        This method will cache the revision history for as long as it is safe to
436
 
        do so.
437
 
        """
438
 
        if self._revision_history_cache is not None:
439
 
            history = self._revision_history_cache
440
 
        else:
441
 
            history = self._gen_revision_history()
442
 
            self._cache_revision_history(history)
443
 
        return list(history)
 
287
        """Return sequence of revision hashes on to this branch."""
 
288
        raise NotImplementedError('revision_history is abstract')
444
289
 
445
290
    def revno(self):
446
291
        """Return current revision number for this branch.
454
299
        """Older format branches cannot bind or unbind."""
455
300
        raise errors.UpgradeRequired(self.base)
456
301
 
457
 
    def set_append_revisions_only(self, enabled):
458
 
        """Older format branches are never restricted to append-only"""
459
 
        raise errors.UpgradeRequired(self.base)
460
 
 
461
302
    def last_revision(self):
462
 
        """Return last revision id, or None"""
 
303
        """Return last patch hash, or None if no history."""
463
304
        ph = self.revision_history()
464
305
        if ph:
465
306
            return ph[-1]
466
307
        else:
467
308
            return None
468
309
 
469
 
    def last_revision_info(self):
470
 
        """Return information about the last revision.
471
 
 
472
 
        :return: A tuple (revno, last_revision_id).
473
 
        """
474
 
        rh = self.revision_history()
475
 
        revno = len(rh)
476
 
        if revno:
477
 
            return (revno, rh[-1])
478
 
        else:
479
 
            return (0, _mod_revision.NULL_REVISION)
480
 
 
481
310
    def missing_revisions(self, other, stop_revision=None):
482
311
        """Return a list of new revisions that would perfectly fit.
483
312
        
508
337
        :param stop_revision: Updated until the given revision
509
338
        :return: None
510
339
        """
511
 
        raise NotImplementedError(self.update_revisions)
 
340
        raise NotImplementedError('update_revisions is abstract')
512
341
 
513
342
    def revision_id_to_revno(self, revision_id):
514
343
        """Given a revision id, return its revno"""
515
 
        if _mod_revision.is_null(revision_id):
 
344
        if revision_id is None:
516
345
            return 0
517
 
        revision_id = osutils.safe_revision_id(revision_id)
518
346
        history = self.revision_history()
519
347
        try:
520
348
            return history.index(revision_id) + 1
521
349
        except ValueError:
522
 
            raise errors.NoSuchRevision(self, revision_id)
 
350
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
523
351
 
524
352
    def get_rev_id(self, revno, history=None):
525
353
        """Find the revision id of the specified revno."""
527
355
            return None
528
356
        if history is None:
529
357
            history = self.revision_history()
530
 
        if revno <= 0 or revno > len(history):
531
 
            raise errors.NoSuchRevision(self, revno)
 
358
        elif revno <= 0 or revno > len(history):
 
359
            raise bzrlib.errors.NoSuchRevision(self, revno)
532
360
        return history[revno - 1]
533
361
 
534
362
    def pull(self, source, overwrite=False, stop_revision=None):
535
 
        """Mirror source into this branch.
536
 
 
537
 
        This branch is considered to be 'local', having low latency.
538
 
 
539
 
        :returns: PullResult instance
540
 
        """
541
 
        raise NotImplementedError(self.pull)
542
 
 
543
 
    def push(self, target, overwrite=False, stop_revision=None):
544
 
        """Mirror this branch into target.
545
 
 
546
 
        This branch is considered to be 'local', having low latency.
547
 
        """
548
 
        raise NotImplementedError(self.push)
 
363
        raise NotImplementedError('pull is abstract')
549
364
 
550
365
    def basis_tree(self):
551
 
        """Return `Tree` object for last revision."""
 
366
        """Return `Tree` object for last revision.
 
367
 
 
368
        If there are no revisions yet, return an `EmptyTree`.
 
369
        """
552
370
        return self.repository.revision_tree(self.last_revision())
553
371
 
554
372
    def rename_one(self, from_rel, to_rel):
556
374
 
557
375
        This can change the directory or the filename or both.
558
376
        """
559
 
        raise NotImplementedError(self.rename_one)
 
377
        raise NotImplementedError('rename_one is abstract')
560
378
 
561
379
    def move(self, from_paths, to_name):
562
380
        """Rename files.
572
390
        This returns a list of (from_path, to_path) pairs for each
573
391
        entry that is moved.
574
392
        """
575
 
        raise NotImplementedError(self.move)
 
393
        raise NotImplementedError('move is abstract')
576
394
 
577
395
    def get_parent(self):
578
396
        """Return the parent location of the branch.
581
399
        pattern is that the user can override it by specifying a
582
400
        location.
583
401
        """
584
 
        raise NotImplementedError(self.get_parent)
585
 
 
586
 
    def _set_config_location(self, name, url, config=None,
587
 
                             make_relative=False):
588
 
        if config is None:
589
 
            config = self.get_config()
590
 
        if url is None:
591
 
            url = ''
592
 
        elif make_relative:
593
 
            url = urlutils.relative_url(self.base, url)
594
 
        config.set_user_option(name, url, warn_masked=True)
595
 
 
596
 
    def _get_config_location(self, name, config=None):
597
 
        if config is None:
598
 
            config = self.get_config()
599
 
        location = config.get_user_option(name)
600
 
        if location == '':
601
 
            location = None
602
 
        return location
 
402
        raise NotImplementedError('get_parent is abstract')
603
403
 
604
404
    def get_submit_branch(self):
605
405
        """Return the submit location of the branch.
617
417
        pattern is that the user can override it by specifying a
618
418
        location.
619
419
        """
620
 
        self.get_config().set_user_option('submit_branch', location,
621
 
            warn_masked=True)
622
 
 
623
 
    def get_public_branch(self):
624
 
        """Return the public location of the branch.
625
 
 
626
 
        This is is used by merge directives.
627
 
        """
628
 
        return self._get_config_location('public_branch')
629
 
 
630
 
    def set_public_branch(self, location):
631
 
        """Return the submit location of the branch.
632
 
 
633
 
        This is the default location for bundle.  The usual
634
 
        pattern is that the user can override it by specifying a
635
 
        location.
636
 
        """
637
 
        self._set_config_location('public_branch', location)
 
420
        self.get_config().set_user_option('submit_branch', location)
638
421
 
639
422
    def get_push_location(self):
640
423
        """Return the None or the location to push this branch to."""
641
 
        push_loc = self.get_config().get_user_option('push_location')
642
 
        return push_loc
 
424
        raise NotImplementedError('get_push_location is abstract')
643
425
 
644
426
    def set_push_location(self, location):
645
427
        """Set a new push location for this branch."""
646
 
        raise NotImplementedError(self.set_push_location)
 
428
        raise NotImplementedError('set_push_location is abstract')
647
429
 
648
430
    def set_parent(self, url):
649
 
        raise NotImplementedError(self.set_parent)
 
431
        raise NotImplementedError('set_parent is abstract')
650
432
 
651
433
    @needs_write_lock
652
434
    def update(self):
673
455
            raise InvalidRevisionNumber(revno)
674
456
 
675
457
    @needs_read_lock
676
 
    def clone(self, to_bzrdir, revision_id=None):
 
458
    def clone(self, *args, **kwargs):
677
459
        """Clone this branch into to_bzrdir preserving all semantic values.
678
460
        
679
461
        revision_id: if not None, the revision history in the new branch will
680
462
                     be truncated to end with revision_id.
681
463
        """
 
464
        # for API compatibility, until 0.8 releases we provide the old api:
 
465
        # def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
 
466
        # after 0.8 releases, the *args and **kwargs should be changed:
 
467
        # def clone(self, to_bzrdir, revision_id=None):
 
468
        if (kwargs.get('to_location', None) or
 
469
            kwargs.get('revision', None) or
 
470
            kwargs.get('basis_branch', None) or
 
471
            (len(args) and isinstance(args[0], basestring))):
 
472
            # backwards compatibility api:
 
473
            warn("Branch.clone() has been deprecated for BzrDir.clone() from"
 
474
                 " bzrlib 0.8.", DeprecationWarning, stacklevel=3)
 
475
            # get basis_branch
 
476
            if len(args) > 2:
 
477
                basis_branch = args[2]
 
478
            else:
 
479
                basis_branch = kwargs.get('basis_branch', None)
 
480
            if basis_branch:
 
481
                basis = basis_branch.bzrdir
 
482
            else:
 
483
                basis = None
 
484
            # get revision
 
485
            if len(args) > 1:
 
486
                revision_id = args[1]
 
487
            else:
 
488
                revision_id = kwargs.get('revision', None)
 
489
            # get location
 
490
            if len(args):
 
491
                url = args[0]
 
492
            else:
 
493
                # no default to raise if not provided.
 
494
                url = kwargs.get('to_location')
 
495
            return self.bzrdir.clone(url,
 
496
                                     revision_id=revision_id,
 
497
                                     basis=basis).open_branch()
 
498
        # new cleaner api.
 
499
        # generate args by hand 
 
500
        if len(args) > 1:
 
501
            revision_id = args[1]
 
502
        else:
 
503
            revision_id = kwargs.get('revision_id', None)
 
504
        if len(args):
 
505
            to_bzrdir = args[0]
 
506
        else:
 
507
            # no default to raise if not provided.
 
508
            to_bzrdir = kwargs.get('to_bzrdir')
682
509
        result = self._format.initialize(to_bzrdir)
683
510
        self.copy_content_into(result, revision_id=revision_id)
684
511
        return  result
695
522
        result.set_parent(self.bzrdir.root_transport.base)
696
523
        return result
697
524
 
698
 
    def _synchronize_history(self, destination, revision_id):
699
 
        """Synchronize last revision and revision history between branches.
700
 
 
701
 
        This version is most efficient when the destination is also a
702
 
        BzrBranch5, but works for BzrBranch6 as long as the revision
703
 
        history is the true lefthand parent history, and all of the revisions
704
 
        are in the destination's repository.  If not, set_revision_history
705
 
        will fail.
706
 
 
707
 
        :param destination: The branch to copy the history into
708
 
        :param revision_id: The revision-id to truncate history at.  May
709
 
          be None to copy complete history.
 
525
    @needs_read_lock
 
526
    def copy_content_into(self, destination, revision_id=None):
 
527
        """Copy the content of self into destination.
 
528
 
 
529
        revision_id: if not None, the revision history in the new branch will
 
530
                     be truncated to end with revision_id.
710
531
        """
711
 
        if revision_id == _mod_revision.NULL_REVISION:
712
 
            new_history = []
713
532
        new_history = self.revision_history()
714
 
        if revision_id is not None and new_history != []:
715
 
            revision_id = osutils.safe_revision_id(revision_id)
 
533
        if revision_id is not None:
716
534
            try:
717
535
                new_history = new_history[:new_history.index(revision_id) + 1]
718
536
            except ValueError:
719
537
                rev = self.repository.get_revision(revision_id)
720
538
                new_history = rev.get_history(self.repository)[1:]
721
539
        destination.set_revision_history(new_history)
722
 
 
723
 
    @needs_read_lock
724
 
    def copy_content_into(self, destination, revision_id=None):
725
 
        """Copy the content of self into destination.
726
 
 
727
 
        revision_id: if not None, the revision history in the new branch will
728
 
                     be truncated to end with revision_id.
729
 
        """
730
 
        self._synchronize_history(destination, revision_id)
731
 
        try:
732
 
            parent = self.get_parent()
733
 
        except errors.InaccessibleParent, e:
734
 
            mutter('parent was not accessible to copy: %s', e)
735
 
        else:
736
 
            if parent:
737
 
                destination.set_parent(parent)
738
 
        self.tags.merge_to(destination.tags)
 
540
        parent = self.get_parent()
 
541
        if parent:
 
542
            destination.set_parent(parent)
739
543
 
740
544
    @needs_read_lock
741
545
    def check(self):
767
571
            mainline_parent_id = revision_id
768
572
        return BranchCheckResult(self)
769
573
 
770
 
    def _get_checkout_format(self):
771
 
        """Return the most suitable metadir for a checkout of this branch.
772
 
        Weaves are used if this branch's repository uses weaves.
773
 
        """
774
 
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
775
 
            from bzrlib.repofmt import weaverepo
776
 
            format = bzrdir.BzrDirMetaFormat1()
777
 
            format.repository_format = weaverepo.RepositoryFormat7()
778
 
        else:
779
 
            format = self.repository.bzrdir.checkout_metadir()
780
 
            format.set_branch_format(self._format)
781
 
        return format
782
 
 
783
 
    def create_checkout(self, to_location, revision_id=None,
784
 
                        lightweight=False):
785
 
        """Create a checkout of a branch.
786
 
        
787
 
        :param to_location: The url to produce the checkout at
788
 
        :param revision_id: The revision to check out
789
 
        :param lightweight: If True, produce a lightweight checkout, otherwise,
790
 
        produce a bound branch (heavyweight checkout)
791
 
        :return: The tree of the created checkout
792
 
        """
793
 
        t = transport.get_transport(to_location)
794
 
        t.ensure_base()
795
 
        if lightweight:
796
 
            format = self._get_checkout_format()
797
 
            checkout = format.initialize_on_transport(t)
798
 
            BranchReferenceFormat().initialize(checkout, self)
799
 
        else:
800
 
            format = self._get_checkout_format()
801
 
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
802
 
                to_location, force_new_tree=False, format=format)
803
 
            checkout = checkout_branch.bzrdir
804
 
            checkout_branch.bind(self)
805
 
            # pull up to the specified revision_id to set the initial 
806
 
            # branch tip correctly, and seed it with history.
807
 
            checkout_branch.pull(self, stop_revision=revision_id)
808
 
        tree = checkout.create_workingtree(revision_id)
809
 
        basis_tree = tree.basis_tree()
810
 
        basis_tree.lock_read()
811
 
        try:
812
 
            for path, file_id in basis_tree.iter_references():
813
 
                reference_parent = self.reference_parent(file_id, path)
814
 
                reference_parent.create_checkout(tree.abspath(path),
815
 
                    basis_tree.get_reference_revision(file_id, path),
816
 
                    lightweight)
817
 
        finally:
818
 
            basis_tree.unlock()
819
 
        return tree
820
 
 
821
 
    def reference_parent(self, file_id, path):
822
 
        """Return the parent branch for a tree-reference file_id
823
 
        :param file_id: The file_id of the tree reference
824
 
        :param path: The path of the file_id in the tree
825
 
        :return: A branch associated with the file_id
826
 
        """
827
 
        # FIXME should provide multiple branches, based on config
828
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
829
 
 
830
 
    def supports_tags(self):
831
 
        return self._format.supports_tags()
832
 
 
833
574
 
834
575
class BranchFormat(object):
835
576
    """An encapsulation of the initialization and open routines for a format.
855
596
    _formats = {}
856
597
    """The known formats."""
857
598
 
858
 
    def __eq__(self, other):
859
 
        return self.__class__ is other.__class__
860
 
 
861
 
    def __ne__(self, other):
862
 
        return not (self == other)
863
 
 
864
599
    @classmethod
865
600
    def find_format(klass, a_bzrdir):
866
601
        """Return the format for the branch object in a_bzrdir."""
878
613
        """Return the current default format."""
879
614
        return klass._default_format
880
615
 
881
 
    def get_reference(self, a_bzrdir):
882
 
        """Get the target reference of the branch in a_bzrdir.
883
 
 
884
 
        format probing must have been completed before calling
885
 
        this method - it is assumed that the format of the branch
886
 
        in a_bzrdir is correct.
887
 
 
888
 
        :param a_bzrdir: The bzrdir to get the branch data from.
889
 
        :return: None if the branch is not a reference branch.
890
 
        """
891
 
        return None
892
 
 
893
616
    def get_format_string(self):
894
617
        """Return the ASCII format string that identifies this format."""
895
618
        raise NotImplementedError(self.get_format_string)
896
619
 
897
620
    def get_format_description(self):
898
621
        """Return the short format description for this format."""
899
 
        raise NotImplementedError(self.get_format_description)
900
 
 
901
 
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
902
 
                           set_format=True):
903
 
        """Initialize a branch in a bzrdir, with specified files
904
 
 
905
 
        :param a_bzrdir: The bzrdir to initialize the branch in
906
 
        :param utf8_files: The files to create as a list of
907
 
            (filename, content) tuples
908
 
        :param set_format: If True, set the format with
909
 
            self.get_format_string.  (BzrBranch4 has its format set
910
 
            elsewhere)
911
 
        :return: a branch in this format
912
 
        """
913
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
914
 
        branch_transport = a_bzrdir.get_branch_transport(self)
915
 
        lock_map = {
916
 
            'metadir': ('lock', lockdir.LockDir),
917
 
            'branch4': ('branch-lock', lockable_files.TransportLock),
918
 
        }
919
 
        lock_name, lock_class = lock_map[lock_type]
920
 
        control_files = lockable_files.LockableFiles(branch_transport,
921
 
            lock_name, lock_class)
922
 
        control_files.create_lock()
923
 
        control_files.lock_write()
924
 
        if set_format:
925
 
            control_files.put_utf8('format', self.get_format_string())
926
 
        try:
927
 
            for file, content in utf8_files:
928
 
                control_files.put_utf8(file, content)
929
 
        finally:
930
 
            control_files.unlock()
931
 
        return self.open(a_bzrdir, _found=True)
 
622
        raise NotImplementedError(self.get_format_string)
932
623
 
933
624
    def initialize(self, a_bzrdir):
934
625
        """Create a branch of this format in a_bzrdir."""
967
658
    def __str__(self):
968
659
        return self.get_format_string().rstrip()
969
660
 
970
 
    def supports_tags(self):
971
 
        """True if this format supports tags stored in the branch"""
972
 
        return False  # by default
973
 
 
974
 
    # XXX: Probably doesn't really belong here -- mbp 20070212
975
 
    def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
976
 
            lock_class):
977
 
        branch_transport = a_bzrdir.get_branch_transport(self)
978
 
        control_files = lockable_files.LockableFiles(branch_transport,
979
 
            lock_filename, lock_class)
980
 
        control_files.create_lock()
981
 
        control_files.lock_write()
982
 
        try:
983
 
            for filename, content in utf8_files:
984
 
                control_files.put_utf8(filename, content)
985
 
        finally:
986
 
            control_files.unlock()
987
 
 
988
 
 
989
 
class BranchHooks(Hooks):
990
 
    """A dictionary mapping hook name to a list of callables for branch hooks.
991
 
    
992
 
    e.g. ['set_rh'] Is the list of items to be called when the
993
 
    set_revision_history function is invoked.
994
 
    """
995
 
 
996
 
    def __init__(self):
997
 
        """Create the default hooks.
998
 
 
999
 
        These are all empty initially, because by default nothing should get
1000
 
        notified.
1001
 
        """
1002
 
        Hooks.__init__(self)
1003
 
        # Introduced in 0.15:
1004
 
        # invoked whenever the revision history has been set
1005
 
        # with set_revision_history. The api signature is
1006
 
        # (branch, revision_history), and the branch will
1007
 
        # be write-locked.
1008
 
        self['set_rh'] = []
1009
 
        # invoked after a push operation completes.
1010
 
        # the api signature is
1011
 
        # (push_result)
1012
 
        # containing the members
1013
 
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
1014
 
        # where local is the local target branch or None, master is the target 
1015
 
        # master branch, and the rest should be self explanatory. The source
1016
 
        # is read locked and the target branches write locked. Source will
1017
 
        # be the local low-latency branch.
1018
 
        self['post_push'] = []
1019
 
        # invoked after a pull operation completes.
1020
 
        # the api signature is
1021
 
        # (pull_result)
1022
 
        # containing the members
1023
 
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
1024
 
        # where local is the local branch or None, master is the target 
1025
 
        # master branch, and the rest should be self explanatory. The source
1026
 
        # is read locked and the target branches write locked. The local
1027
 
        # branch is the low-latency branch.
1028
 
        self['post_pull'] = []
1029
 
        # invoked after a commit operation completes.
1030
 
        # the api signature is 
1031
 
        # (local, master, old_revno, old_revid, new_revno, new_revid)
1032
 
        # old_revid is NULL_REVISION for the first commit to a branch.
1033
 
        self['post_commit'] = []
1034
 
        # invoked after a uncommit operation completes.
1035
 
        # the api signature is
1036
 
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
1037
 
        # local is the local branch or None, master is the target branch,
1038
 
        # and an empty branch recieves new_revno of 0, new_revid of None.
1039
 
        self['post_uncommit'] = []
1040
 
 
1041
 
 
1042
 
# install the default hooks into the Branch class.
1043
 
Branch.hooks = BranchHooks()
1044
 
 
1045
661
 
1046
662
class BzrBranchFormat4(BranchFormat):
1047
663
    """Bzr branch format 4.
1057
673
 
1058
674
    def initialize(self, a_bzrdir):
1059
675
        """Create a branch of this format in a_bzrdir."""
 
676
        mutter('creating branch in %s', a_bzrdir.transport.base)
 
677
        branch_transport = a_bzrdir.get_branch_transport(self)
1060
678
        utf8_files = [('revision-history', ''),
1061
679
                      ('branch-name', ''),
1062
680
                      ]
1063
 
        return self._initialize_helper(a_bzrdir, utf8_files,
1064
 
                                       lock_type='branch4', set_format=False)
 
681
        control_files = LockableFiles(branch_transport, 'branch-lock',
 
682
                                      TransportLock)
 
683
        control_files.create_lock()
 
684
        control_files.lock_write()
 
685
        try:
 
686
            for file, content in utf8_files:
 
687
                control_files.put_utf8(file, content)
 
688
        finally:
 
689
            control_files.unlock()
 
690
        return self.open(a_bzrdir, _found=True)
1065
691
 
1066
692
    def __init__(self):
1067
693
        super(BzrBranchFormat4, self).__init__()
1108
734
        
1109
735
    def initialize(self, a_bzrdir):
1110
736
        """Create a branch of this format in a_bzrdir."""
 
737
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
738
        branch_transport = a_bzrdir.get_branch_transport(self)
1111
739
        utf8_files = [('revision-history', ''),
1112
740
                      ('branch-name', ''),
1113
741
                      ]
1114
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
742
        control_files = LockableFiles(branch_transport, 'lock', lockdir.LockDir)
 
743
        control_files.create_lock()
 
744
        control_files.lock_write()
 
745
        control_files.put_utf8('format', self.get_format_string())
 
746
        try:
 
747
            for file, content in utf8_files:
 
748
                control_files.put_utf8(file, content)
 
749
        finally:
 
750
            control_files.unlock()
 
751
        return self.open(a_bzrdir, _found=True, )
1115
752
 
1116
753
    def __init__(self):
1117
754
        super(BzrBranchFormat5, self).__init__()
1126
763
        if not _found:
1127
764
            format = BranchFormat.find_format(a_bzrdir)
1128
765
            assert format.__class__ == self.__class__
1129
 
        try:
1130
 
            transport = a_bzrdir.get_branch_transport(None)
1131
 
            control_files = lockable_files.LockableFiles(transport, 'lock',
1132
 
                                                         lockdir.LockDir)
1133
 
            return BzrBranch5(_format=self,
1134
 
                              _control_files=control_files,
1135
 
                              a_bzrdir=a_bzrdir,
1136
 
                              _repository=a_bzrdir.find_repository())
1137
 
        except NoSuchFile:
1138
 
            raise NotBranchError(path=transport.base)
1139
 
 
1140
 
 
1141
 
class BzrBranchFormat6(BzrBranchFormat5):
1142
 
    """Branch format with last-revision
1143
 
 
1144
 
    Unlike previous formats, this has no explicit revision history. Instead,
1145
 
    this just stores the last-revision, and the left-hand history leading
1146
 
    up to there is the history.
1147
 
 
1148
 
    This format was introduced in bzr 0.15
1149
 
    """
1150
 
 
1151
 
    def get_format_string(self):
1152
 
        """See BranchFormat.get_format_string()."""
1153
 
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
1154
 
 
1155
 
    def get_format_description(self):
1156
 
        """See BranchFormat.get_format_description()."""
1157
 
        return "Branch format 6"
1158
 
 
1159
 
    def initialize(self, a_bzrdir):
1160
 
        """Create a branch of this format in a_bzrdir."""
1161
 
        utf8_files = [('last-revision', '0 null:\n'),
1162
 
                      ('branch-name', ''),
1163
 
                      ('branch.conf', ''),
1164
 
                      ('tags', ''),
1165
 
                      ]
1166
 
        return self._initialize_helper(a_bzrdir, utf8_files)
1167
 
 
1168
 
    def open(self, a_bzrdir, _found=False):
1169
 
        """Return the branch object for a_bzrdir
1170
 
 
1171
 
        _found is a private parameter, do not use it. It is used to indicate
1172
 
               if format probing has already be done.
1173
 
        """
1174
 
        if not _found:
1175
 
            format = BranchFormat.find_format(a_bzrdir)
1176
 
            assert format.__class__ == self.__class__
1177
766
        transport = a_bzrdir.get_branch_transport(None)
1178
 
        control_files = lockable_files.LockableFiles(transport, 'lock',
1179
 
                                                     lockdir.LockDir)
1180
 
        return BzrBranch6(_format=self,
 
767
        control_files = LockableFiles(transport, 'lock', lockdir.LockDir)
 
768
        return BzrBranch5(_format=self,
1181
769
                          _control_files=control_files,
1182
770
                          a_bzrdir=a_bzrdir,
1183
771
                          _repository=a_bzrdir.find_repository())
1184
772
 
1185
 
    def supports_tags(self):
1186
 
        return True
 
773
    def __str__(self):
 
774
        return "Bazaar-NG Metadir branch format 5"
1187
775
 
1188
776
 
1189
777
class BranchReferenceFormat(BranchFormat):
1205
793
        """See BranchFormat.get_format_description()."""
1206
794
        return "Checkout reference format 1"
1207
795
        
1208
 
    def get_reference(self, a_bzrdir):
1209
 
        """See BranchFormat.get_reference()."""
1210
 
        transport = a_bzrdir.get_branch_transport(None)
1211
 
        return transport.get('location').read()
1212
 
 
1213
796
    def initialize(self, a_bzrdir, target_branch=None):
1214
797
        """Create a branch of this format in a_bzrdir."""
1215
798
        if target_branch is None:
1218
801
            raise errors.UninitializableFormat(self)
1219
802
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
1220
803
        branch_transport = a_bzrdir.get_branch_transport(self)
1221
 
        branch_transport.put_bytes('location',
1222
 
            target_branch.bzrdir.root_transport.base)
1223
 
        branch_transport.put_bytes('format', self.get_format_string())
 
804
        # FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
 
805
        branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
 
806
        branch_transport.put('format', StringIO(self.get_format_string()))
1224
807
        return self.open(a_bzrdir, _found=True)
1225
808
 
1226
809
    def __init__(self):
1237
820
            # emit some sort of warning/error to the caller ?!
1238
821
        return clone
1239
822
 
1240
 
    def open(self, a_bzrdir, _found=False, location=None):
 
823
    def open(self, a_bzrdir, _found=False):
1241
824
        """Return the branch that the branch reference in a_bzrdir points at.
1242
825
 
1243
826
        _found is a private parameter, do not use it. It is used to indicate
1246
829
        if not _found:
1247
830
            format = BranchFormat.find_format(a_bzrdir)
1248
831
            assert format.__class__ == self.__class__
1249
 
        if location is None:
1250
 
            location = self.get_reference(a_bzrdir)
1251
 
        real_bzrdir = bzrdir.BzrDir.open(location)
 
832
        transport = a_bzrdir.get_branch_transport(None)
 
833
        real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
1252
834
        result = real_bzrdir.open_branch()
1253
835
        # this changes the behaviour of result.clone to create a new reference
1254
836
        # rather than a copy of the content of the branch.
1267
849
__default_format = BzrBranchFormat5()
1268
850
BranchFormat.register_format(__default_format)
1269
851
BranchFormat.register_format(BranchReferenceFormat())
1270
 
BranchFormat.register_format(BzrBranchFormat6())
1271
852
BranchFormat.set_default_format(__default_format)
1272
853
_legacy_formats = [BzrBranchFormat4(),
1273
854
                   ]
1280
861
    it's writable, and can be accessed via the normal filesystem API.
1281
862
    """
1282
863
    
1283
 
    def __init__(self, _format=None,
 
864
    def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
 
865
                 relax_version_check=DEPRECATED_PARAMETER, _format=None,
1284
866
                 _control_files=None, a_bzrdir=None, _repository=None):
1285
 
        """Create new branch object at a particular location."""
1286
 
        Branch.__init__(self)
 
867
        """Create new branch object at a particular location.
 
868
 
 
869
        transport -- A Transport object, defining how to access files.
 
870
        
 
871
        init -- If True, create new control files in a previously
 
872
             unversioned directory.  If False, the branch must already
 
873
             be versioned.
 
874
 
 
875
        relax_version_check -- If true, the usual check for the branch
 
876
            version is not applied.  This is intended only for
 
877
            upgrade/recovery type use; it's not guaranteed that
 
878
            all operations will work on old format branches.
 
879
        """
1287
880
        if a_bzrdir is None:
1288
 
            raise ValueError('a_bzrdir must be supplied')
 
881
            self.bzrdir = bzrdir.BzrDir.open(transport.base)
1289
882
        else:
1290
883
            self.bzrdir = a_bzrdir
1291
 
        # self._transport used to point to the directory containing the
1292
 
        # control directory, but was not used - now it's just the transport
1293
 
        # for the branch control files.  mbp 20070212
1294
 
        self._base = self.bzrdir.transport.clone('..').base
 
884
        self._transport = self.bzrdir.transport.clone('..')
 
885
        self._base = self._transport.base
1295
886
        self._format = _format
1296
887
        if _control_files is None:
1297
888
            raise ValueError('BzrBranch _control_files is None')
1298
889
        self.control_files = _control_files
1299
 
        self._transport = _control_files._transport
 
890
        if deprecated_passed(init):
 
891
            warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
 
892
                 "deprecated as of bzr 0.8. Please use Branch.create().",
 
893
                 DeprecationWarning,
 
894
                 stacklevel=2)
 
895
            if init:
 
896
                # this is slower than before deprecation, oh well never mind.
 
897
                # -> its deprecated.
 
898
                self._initialize(transport.base)
 
899
        self._check_format(_format)
 
900
        if deprecated_passed(relax_version_check):
 
901
            warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
 
902
                 "relax_version_check parameter is deprecated as of bzr 0.8. "
 
903
                 "Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
 
904
                 "open() method.",
 
905
                 DeprecationWarning,
 
906
                 stacklevel=2)
 
907
            if (not relax_version_check
 
908
                and not self._format.is_supported()):
 
909
                raise errors.UnsupportedFormatError(format=fmt)
 
910
        if deprecated_passed(transport):
 
911
            warn("BzrBranch.__init__(transport=XXX...): The transport "
 
912
                 "parameter is deprecated as of bzr 0.8. "
 
913
                 "Please use Branch.open, or bzrdir.open_branch().",
 
914
                 DeprecationWarning,
 
915
                 stacklevel=2)
1300
916
        self.repository = _repository
1301
917
 
1302
918
    def __str__(self):
1304
920
 
1305
921
    __repr__ = __str__
1306
922
 
 
923
    def __del__(self):
 
924
        # TODO: It might be best to do this somewhere else,
 
925
        # but it is nice for a Branch object to automatically
 
926
        # cache it's information.
 
927
        # Alternatively, we could have the Transport objects cache requests
 
928
        # See the earlier discussion about how major objects (like Branch)
 
929
        # should never expect their __del__ function to run.
 
930
        # XXX: cache_root seems to be unused, 2006-01-13 mbp
 
931
        if hasattr(self, 'cache_root') and self.cache_root is not None:
 
932
            try:
 
933
                osutils.rmtree(self.cache_root)
 
934
            except:
 
935
                pass
 
936
            self.cache_root = None
 
937
 
1307
938
    def _get_base(self):
1308
 
        """Returns the directory containing the control directory."""
1309
939
        return self._base
1310
940
 
1311
941
    base = property(_get_base, doc="The URL for the root of this branch.")
1312
942
 
 
943
    def _finish_transaction(self):
 
944
        """Exit the current transaction."""
 
945
        return self.control_files._finish_transaction()
 
946
 
 
947
    def get_transaction(self):
 
948
        """Return the current active transaction.
 
949
 
 
950
        If no transaction is active, this returns a passthrough object
 
951
        for which all data is immediately flushed and no caching happens.
 
952
        """
 
953
        # this is an explicit function so that we can do tricky stuff
 
954
        # when the storage in rev_storage is elsewhere.
 
955
        # we probably need to hook the two 'lock a location' and 
 
956
        # 'have a transaction' together more delicately, so that
 
957
        # we can have two locks (branch and storage) and one transaction
 
958
        # ... and finishing the transaction unlocks both, but unlocking
 
959
        # does not. - RBC 20051121
 
960
        return self.control_files.get_transaction()
 
961
 
 
962
    def _set_transaction(self, transaction):
 
963
        """Set a new active transaction."""
 
964
        return self.control_files._set_transaction(transaction)
 
965
 
1313
966
    def abspath(self, name):
1314
967
        """See Branch.abspath."""
1315
968
        return self.control_files._transport.abspath(name)
1316
969
 
1317
 
 
1318
 
    @deprecated_method(zero_sixteen)
 
970
    def _check_format(self, format):
 
971
        """Identify the branch format if needed.
 
972
 
 
973
        The format is stored as a reference to the format object in
 
974
        self._format for code that needs to check it later.
 
975
 
 
976
        The format parameter is either None or the branch format class
 
977
        used to open this branch.
 
978
 
 
979
        FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
 
980
        """
 
981
        if format is None:
 
982
            format = BranchFormat.find_format(self.bzrdir)
 
983
        self._format = format
 
984
        mutter("got branch format %s", self._format)
 
985
 
1319
986
    @needs_read_lock
1320
987
    def get_root_id(self):
1321
988
        """See Branch.get_root_id."""
1325
992
    def is_locked(self):
1326
993
        return self.control_files.is_locked()
1327
994
 
1328
 
    def lock_write(self, token=None):
1329
 
        repo_token = self.repository.lock_write()
1330
 
        try:
1331
 
            token = self.control_files.lock_write(token=token)
1332
 
        except:
1333
 
            self.repository.unlock()
1334
 
            raise
1335
 
        return token
 
995
    def lock_write(self):
 
996
        # TODO: test for failed two phase locks. This is known broken.
 
997
        self.control_files.lock_write()
 
998
        self.repository.lock_write()
1336
999
 
1337
1000
    def lock_read(self):
 
1001
        # TODO: test for failed two phase locks. This is known broken.
 
1002
        self.control_files.lock_read()
1338
1003
        self.repository.lock_read()
1339
 
        try:
1340
 
            self.control_files.lock_read()
1341
 
        except:
1342
 
            self.repository.unlock()
1343
 
            raise
1344
1004
 
1345
1005
    def unlock(self):
1346
1006
        # TODO: test for failed two phase locks. This is known broken.
1347
1007
        try:
 
1008
            self.repository.unlock()
 
1009
        finally:
1348
1010
            self.control_files.unlock()
1349
 
        finally:
1350
 
            self.repository.unlock()
1351
 
        if not self.control_files.is_locked():
1352
 
            # we just released the lock
1353
 
            self._clear_cached_state()
1354
1011
        
1355
1012
    def peek_lock_mode(self):
1356
1013
        if self.control_files._lock_count == 0:
1369
1026
    @needs_write_lock
1370
1027
    def append_revision(self, *revision_ids):
1371
1028
        """See Branch.append_revision."""
1372
 
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1373
1029
        for revision_id in revision_ids:
1374
 
            _mod_revision.check_not_reserved_id(revision_id)
1375
1030
            mutter("add {%s} to revision-history" % revision_id)
1376
1031
        rev_history = self.revision_history()
1377
1032
        rev_history.extend(revision_ids)
1378
1033
        self.set_revision_history(rev_history)
1379
1034
 
1380
 
    def _write_revision_history(self, history):
1381
 
        """Factored out of set_revision_history.
1382
 
 
1383
 
        This performs the actual writing to disk.
1384
 
        It is intended to be called by BzrBranch5.set_revision_history."""
1385
 
        self.control_files.put_bytes(
1386
 
            'revision-history', '\n'.join(history))
1387
 
 
1388
1035
    @needs_write_lock
1389
1036
    def set_revision_history(self, rev_history):
1390
1037
        """See Branch.set_revision_history."""
1391
 
        rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1392
 
        self._clear_cached_state()
1393
 
        self._write_revision_history(rev_history)
1394
 
        self._cache_revision_history(rev_history)
1395
 
        for hook in Branch.hooks['set_rh']:
1396
 
            hook(self, rev_history)
 
1038
        self.control_files.put_utf8(
 
1039
            'revision-history', '\n'.join(rev_history))
 
1040
        transaction = self.get_transaction()
 
1041
        history = transaction.map.find_revision_history()
 
1042
        if history is not None:
 
1043
            # update the revision history in the identity map.
 
1044
            history[:] = list(rev_history)
 
1045
            # this call is disabled because revision_history is 
 
1046
            # not really an object yet, and the transaction is for objects.
 
1047
            # transaction.register_dirty(history)
 
1048
        else:
 
1049
            transaction.map.add_revision_history(rev_history)
 
1050
            # this call is disabled because revision_history is 
 
1051
            # not really an object yet, and the transaction is for objects.
 
1052
            # transaction.register_clean(history)
 
1053
 
 
1054
    @needs_read_lock
 
1055
    def revision_history(self):
 
1056
        """See Branch.revision_history."""
 
1057
        transaction = self.get_transaction()
 
1058
        history = transaction.map.find_revision_history()
 
1059
        if history is not None:
 
1060
            mutter("cache hit for revision-history in %s", self)
 
1061
            return list(history)
 
1062
        history = [l.rstrip('\r\n') for l in
 
1063
                self.control_files.get_utf8('revision-history').readlines()]
 
1064
        transaction.map.add_revision_history(history)
 
1065
        # this call is disabled because revision_history is 
 
1066
        # not really an object yet, and the transaction is for objects.
 
1067
        # transaction.register_clean(history, precious=True)
 
1068
        return list(history)
1397
1069
 
1398
1070
    @needs_write_lock
1399
 
    def set_last_revision_info(self, revno, revision_id):
1400
 
        revision_id = osutils.safe_revision_id(revision_id)
1401
 
        history = self._lefthand_history(revision_id)
1402
 
        assert len(history) == revno, '%d != %d' % (len(history), revno)
1403
 
        self.set_revision_history(history)
1404
 
 
1405
 
    def _gen_revision_history(self):
1406
 
        history = self.control_files.get('revision-history').read().split('\n')
1407
 
        if history[-1:] == ['']:
1408
 
            # There shouldn't be a trailing newline, but just in case.
1409
 
            history.pop()
1410
 
        return history
1411
 
 
1412
 
    def _lefthand_history(self, revision_id, last_rev=None,
1413
 
                          other_branch=None):
 
1071
    def generate_revision_history(self, revision_id, last_rev=None, 
 
1072
        other_branch=None):
 
1073
        """Create a new revision history that will finish with revision_id.
 
1074
        
 
1075
        :param revision_id: the new tip to use.
 
1076
        :param last_rev: The previous last_revision. If not None, then this
 
1077
            must be a ancestory of revision_id, or DivergedBranches is raised.
 
1078
        :param other_branch: The other branch that DivergedBranches should
 
1079
            raise with respect to.
 
1080
        """
1414
1081
        # stop_revision must be a descendant of last_revision
1415
1082
        stop_graph = self.repository.get_revision_graph(revision_id)
1416
 
        if (last_rev is not None and last_rev != _mod_revision.NULL_REVISION
1417
 
            and last_rev not in stop_graph):
 
1083
        if last_rev is not None and last_rev not in stop_graph:
1418
1084
            # our previous tip is not merged into stop_revision
1419
1085
            raise errors.DivergedBranches(self, other_branch)
1420
1086
        # make a new revision history from the graph
1421
1087
        current_rev_id = revision_id
1422
1088
        new_history = []
1423
 
        while current_rev_id not in (None, _mod_revision.NULL_REVISION):
 
1089
        while current_rev_id not in (None, revision.NULL_REVISION):
1424
1090
            new_history.append(current_rev_id)
1425
1091
            current_rev_id_parents = stop_graph[current_rev_id]
1426
1092
            try:
1428
1094
            except IndexError:
1429
1095
                current_rev_id = None
1430
1096
        new_history.reverse()
1431
 
        return new_history
1432
 
 
1433
 
    @needs_write_lock
1434
 
    def generate_revision_history(self, revision_id, last_rev=None,
1435
 
        other_branch=None):
1436
 
        """Create a new revision history that will finish with revision_id.
1437
 
 
1438
 
        :param revision_id: the new tip to use.
1439
 
        :param last_rev: The previous last_revision. If not None, then this
1440
 
            must be a ancestory of revision_id, or DivergedBranches is raised.
1441
 
        :param other_branch: The other branch that DivergedBranches should
1442
 
            raise with respect to.
1443
 
        """
1444
 
        revision_id = osutils.safe_revision_id(revision_id)
1445
 
        self.set_revision_history(self._lefthand_history(revision_id,
1446
 
            last_rev, other_branch))
 
1097
        self.set_revision_history(new_history)
1447
1098
 
1448
1099
    @needs_write_lock
1449
1100
    def update_revisions(self, other, stop_revision=None):
1455
1106
                if stop_revision is None:
1456
1107
                    # if there are no commits, we're done.
1457
1108
                    return
1458
 
            else:
1459
 
                stop_revision = osutils.safe_revision_id(stop_revision)
1460
1109
            # whats the current last revision, before we fetch [and change it
1461
1110
            # possibly]
1462
 
            last_rev = _mod_revision.ensure_null(self.last_revision())
 
1111
            last_rev = self.last_revision()
1463
1112
            # we fetch here regardless of whether we need to so that we pickup
1464
1113
            # filled in ghosts.
1465
1114
            self.fetch(other, stop_revision)
1466
 
            my_ancestry = self.repository.get_ancestry(last_rev,
1467
 
                                                       topo_sorted=False)
 
1115
            my_ancestry = self.repository.get_ancestry(last_rev)
1468
1116
            if stop_revision in my_ancestry:
1469
1117
                # last_revision is a descendant of stop_revision
1470
1118
                return
1488
1136
        return self.bzrdir.open_workingtree()
1489
1137
 
1490
1138
    @needs_write_lock
1491
 
    def pull(self, source, overwrite=False, stop_revision=None,
1492
 
             _hook_master=None, run_hooks=True):
1493
 
        """See Branch.pull.
1494
 
 
1495
 
        :param _hook_master: Private parameter - set the branch to 
1496
 
            be supplied as the master to push hooks.
1497
 
        :param run_hooks: Private parameter - if false, this branch
1498
 
            is being called because it's the master of the primary branch,
1499
 
            so it should not run its hooks.
1500
 
        """
1501
 
        result = PullResult()
1502
 
        result.source_branch = source
1503
 
        result.target_branch = self
 
1139
    def pull(self, source, overwrite=False, stop_revision=None):
 
1140
        """See Branch.pull."""
1504
1141
        source.lock_read()
1505
1142
        try:
1506
 
            result.old_revno, result.old_revid = self.last_revision_info()
 
1143
            old_count = len(self.revision_history())
1507
1144
            try:
1508
 
                self.update_revisions(source, stop_revision)
 
1145
                self.update_revisions(source,stop_revision)
1509
1146
            except DivergedBranches:
1510
1147
                if not overwrite:
1511
1148
                    raise
1512
1149
            if overwrite:
1513
 
                if stop_revision is None:
1514
 
                    stop_revision = source.last_revision()
1515
 
                self.generate_revision_history(stop_revision)
1516
 
            result.tag_conflicts = source.tags.merge_to(self.tags)
1517
 
            result.new_revno, result.new_revid = self.last_revision_info()
1518
 
            if _hook_master:
1519
 
                result.master_branch = _hook_master
1520
 
                result.local_branch = self
1521
 
            else:
1522
 
                result.master_branch = self
1523
 
                result.local_branch = None
1524
 
            if run_hooks:
1525
 
                for hook in Branch.hooks['post_pull']:
1526
 
                    hook(result)
 
1150
                self.set_revision_history(source.revision_history())
 
1151
            new_count = len(self.revision_history())
 
1152
            return new_count - old_count
1527
1153
        finally:
1528
1154
            source.unlock()
1529
 
        return result
1530
 
 
1531
 
    def _get_parent_location(self):
 
1155
 
 
1156
    def get_parent(self):
 
1157
        """See Branch.get_parent."""
 
1158
 
1532
1159
        _locs = ['parent', 'pull', 'x-pull']
 
1160
        assert self.base[-1] == '/'
1533
1161
        for l in _locs:
1534
1162
            try:
1535
 
                return self.control_files.get(l).read().strip('\n')
 
1163
                parent = self.control_files.get(l).read().strip('\n')
1536
1164
            except NoSuchFile:
1537
 
                pass
1538
 
        return None
1539
 
 
1540
 
    @needs_read_lock
1541
 
    def push(self, target, overwrite=False, stop_revision=None,
1542
 
             _override_hook_source_branch=None):
1543
 
        """See Branch.push.
1544
 
 
1545
 
        This is the basic concrete implementation of push()
1546
 
 
1547
 
        :param _override_hook_source_branch: If specified, run
1548
 
        the hooks passing this Branch as the source, rather than self.  
1549
 
        This is for use of RemoteBranch, where push is delegated to the
1550
 
        underlying vfs-based Branch. 
1551
 
        """
1552
 
        # TODO: Public option to disable running hooks - should be trivial but
1553
 
        # needs tests.
1554
 
        target.lock_write()
1555
 
        try:
1556
 
            result = self._push_with_bound_branches(target, overwrite,
1557
 
                    stop_revision,
1558
 
                    _override_hook_source_branch=_override_hook_source_branch)
1559
 
            return result
1560
 
        finally:
1561
 
            target.unlock()
1562
 
 
1563
 
    def _push_with_bound_branches(self, target, overwrite,
1564
 
            stop_revision,
1565
 
            _override_hook_source_branch=None):
1566
 
        """Push from self into target, and into target's master if any.
1567
 
        
1568
 
        This is on the base BzrBranch class even though it doesn't support 
1569
 
        bound branches because the *target* might be bound.
1570
 
        """
1571
 
        def _run_hooks():
1572
 
            if _override_hook_source_branch:
1573
 
                result.source_branch = _override_hook_source_branch
1574
 
            for hook in Branch.hooks['post_push']:
1575
 
                hook(result)
1576
 
 
1577
 
        bound_location = target.get_bound_location()
1578
 
        if bound_location and target.base != bound_location:
1579
 
            # there is a master branch.
1580
 
            #
1581
 
            # XXX: Why the second check?  Is it even supported for a branch to
1582
 
            # be bound to itself? -- mbp 20070507
1583
 
            master_branch = target.get_master_branch()
1584
 
            master_branch.lock_write()
1585
 
            try:
1586
 
                # push into the master from this branch.
1587
 
                self._basic_push(master_branch, overwrite, stop_revision)
1588
 
                # and push into the target branch from this. Note that we push from
1589
 
                # this branch again, because its considered the highest bandwidth
1590
 
                # repository.
1591
 
                result = self._basic_push(target, overwrite, stop_revision)
1592
 
                result.master_branch = master_branch
1593
 
                result.local_branch = target
1594
 
                _run_hooks()
1595
 
                return result
1596
 
            finally:
1597
 
                master_branch.unlock()
1598
 
        else:
1599
 
            # no master branch
1600
 
            result = self._basic_push(target, overwrite, stop_revision)
1601
 
            # TODO: Why set master_branch and local_branch if there's no
1602
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
1603
 
            # 20070504
1604
 
            result.master_branch = target
1605
 
            result.local_branch = None
1606
 
            _run_hooks()
1607
 
            return result
1608
 
 
1609
 
    def _basic_push(self, target, overwrite, stop_revision):
1610
 
        """Basic implementation of push without bound branches or hooks.
1611
 
 
1612
 
        Must be called with self read locked and target write locked.
1613
 
        """
1614
 
        result = PushResult()
1615
 
        result.source_branch = self
1616
 
        result.target_branch = target
1617
 
        result.old_revno, result.old_revid = target.last_revision_info()
1618
 
        try:
1619
 
            target.update_revisions(self, stop_revision)
1620
 
        except DivergedBranches:
1621
 
            if not overwrite:
1622
 
                raise
1623
 
        if overwrite:
1624
 
            target.set_revision_history(self.revision_history())
1625
 
        result.tag_conflicts = self.tags.merge_to(target.tags)
1626
 
        result.new_revno, result.new_revid = target.last_revision_info()
1627
 
        return result
1628
 
 
1629
 
    def get_parent(self):
1630
 
        """See Branch.get_parent."""
1631
 
 
1632
 
        assert self.base[-1] == '/'
1633
 
        parent = self._get_parent_location()
1634
 
        if parent is None:
1635
 
            return parent
1636
 
        # This is an old-format absolute path to a local branch
1637
 
        # turn it into a url
1638
 
        if parent.startswith('/'):
1639
 
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
1640
 
        try:
 
1165
                continue
 
1166
            # This is an old-format absolute path to a local branch
 
1167
            # turn it into a url
 
1168
            if parent.startswith('/'):
 
1169
                parent = urlutils.local_path_to_url(parent.decode('utf8'))
1641
1170
            return urlutils.join(self.base[:-1], parent)
1642
 
        except errors.InvalidURLJoin, e:
1643
 
            raise errors.InaccessibleParent(parent, self.base)
 
1171
        return None
 
1172
 
 
1173
    def get_push_location(self):
 
1174
        """See Branch.get_push_location."""
 
1175
        push_loc = self.get_config().get_user_option('push_location')
 
1176
        return push_loc
1644
1177
 
1645
1178
    def set_push_location(self, location):
1646
1179
        """See Branch.set_push_location."""
1647
 
        self.get_config().set_user_option(
1648
 
            'push_location', location,
1649
 
            store=_mod_config.STORE_LOCATION_NORECURSE)
 
1180
        self.get_config().set_user_option('push_location', location, 
 
1181
                                          local=True)
1650
1182
 
1651
1183
    @needs_write_lock
1652
1184
    def set_parent(self, url):
1656
1188
        # FIXUP this and get_parent in a future branch format bump:
1657
1189
        # read and rewrite the file, and have the new format code read
1658
1190
        # using .get not .get_utf8. RBC 20060125
1659
 
        if url is not None:
 
1191
        if url is None:
 
1192
            self.control_files._transport.delete('parent')
 
1193
        else:
1660
1194
            if isinstance(url, unicode):
1661
1195
                try: 
1662
1196
                    url = url.encode('ascii')
1663
1197
                except UnicodeEncodeError:
1664
 
                    raise errors.InvalidURL(url,
 
1198
                    raise bzrlib.errors.InvalidURL(url,
1665
1199
                        "Urls must be 7-bit ascii, "
1666
1200
                        "use bzrlib.urlutils.escape")
 
1201
                    
1667
1202
            url = urlutils.relative_url(self.base, url)
1668
 
        self._set_parent_location(url)
1669
 
 
1670
 
    def _set_parent_location(self, url):
1671
 
        if url is None:
1672
 
            self.control_files._transport.delete('parent')
1673
 
        else:
1674
 
            assert isinstance(url, str)
1675
 
            self.control_files.put_bytes('parent', url + '\n')
 
1203
            self.control_files.put('parent', url + '\n')
1676
1204
 
1677
1205
    @deprecated_function(zero_nine)
1678
1206
    def tree_config(self):
1698
1226
                                         _repository=_repository)
1699
1227
        
1700
1228
    @needs_write_lock
1701
 
    def pull(self, source, overwrite=False, stop_revision=None,
1702
 
             run_hooks=True):
1703
 
        """Pull from source into self, updating my master if any.
1704
 
        
1705
 
        :param run_hooks: Private parameter - if false, this branch
1706
 
            is being called because it's the master of the primary branch,
1707
 
            so it should not run its hooks.
1708
 
        """
 
1229
    def pull(self, source, overwrite=False, stop_revision=None):
 
1230
        """Updates branch.pull to be bound branch aware."""
1709
1231
        bound_location = self.get_bound_location()
1710
 
        master_branch = None
1711
 
        if bound_location and source.base != bound_location:
 
1232
        if source.base != bound_location:
1712
1233
            # not pulling from master, so we need to update master.
1713
1234
            master_branch = self.get_master_branch()
1714
 
            master_branch.lock_write()
1715
 
        try:
1716
 
            if master_branch:
1717
 
                # pull from source into master.
1718
 
                master_branch.pull(source, overwrite, stop_revision,
1719
 
                    run_hooks=False)
1720
 
            return super(BzrBranch5, self).pull(source, overwrite,
1721
 
                stop_revision, _hook_master=master_branch,
1722
 
                run_hooks=run_hooks)
1723
 
        finally:
1724
 
            if master_branch:
1725
 
                master_branch.unlock()
 
1235
            if master_branch:
 
1236
                master_branch.pull(source)
 
1237
                source = master_branch
 
1238
        return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
1726
1239
 
1727
1240
    def get_bound_location(self):
1728
1241
        try:
1767
1280
 
1768
1281
    @needs_write_lock
1769
1282
    def bind(self, other):
1770
 
        """Bind this branch to the branch other.
 
1283
        """Bind the local branch the other branch.
1771
1284
 
1772
 
        This does not push or pull data between the branches, though it does
1773
 
        check for divergence to raise an error when the branches are not
1774
 
        either the same, or one a prefix of the other. That behaviour may not
1775
 
        be useful, so that check may be removed in future.
1776
 
        
1777
1285
        :param other: The branch to bind to
1778
1286
        :type other: Branch
1779
1287
        """
1784
1292
        #       but binding itself may not be.
1785
1293
        #       Since we *have* to check at commit time, we don't
1786
1294
        #       *need* to check here
1787
 
 
1788
 
        # we want to raise diverged if:
1789
 
        # last_rev is not in the other_last_rev history, AND
1790
 
        # other_last_rev is not in our history, and do it without pulling
1791
 
        # history around
1792
 
        last_rev = _mod_revision.ensure_null(self.last_revision())
1793
 
        if last_rev != _mod_revision.NULL_REVISION:
1794
 
            other.lock_read()
1795
 
            try:
1796
 
                other_last_rev = other.last_revision()
1797
 
                if not _mod_revision.is_null(other_last_rev):
1798
 
                    # neither branch is new, we have to do some work to
1799
 
                    # ascertain diversion.
1800
 
                    remote_graph = other.repository.get_revision_graph(
1801
 
                        other_last_rev)
1802
 
                    local_graph = self.repository.get_revision_graph(last_rev)
1803
 
                    if (last_rev not in remote_graph and
1804
 
                        other_last_rev not in local_graph):
1805
 
                        raise errors.DivergedBranches(self, other)
1806
 
            finally:
1807
 
                other.unlock()
 
1295
        self.pull(other)
 
1296
 
 
1297
        # we are now equal to or a suffix of other.
 
1298
 
 
1299
        # Since we have 'pulled' from the remote location,
 
1300
        # now we should try to pull in the opposite direction
 
1301
        # in case the local tree has more revisions than the
 
1302
        # remote one.
 
1303
        # There may be a different check you could do here
 
1304
        # rather than actually trying to install revisions remotely.
 
1305
        # TODO: capture an exception which indicates the remote branch
 
1306
        #       is not writable. 
 
1307
        #       If it is up-to-date, this probably should not be a failure
 
1308
        
 
1309
        # lock other for write so the revision-history syncing cannot race
 
1310
        other.lock_write()
 
1311
        try:
 
1312
            other.pull(self)
 
1313
            # if this does not error, other now has the same last rev we do
 
1314
            # it can only error if the pull from other was concurrent with
 
1315
            # a commit to other from someone else.
 
1316
 
 
1317
            # until we ditch revision-history, we need to sync them up:
 
1318
            self.set_revision_history(other.revision_history())
 
1319
            # now other and self are up to date with each other and have the
 
1320
            # same revision-history.
 
1321
        finally:
 
1322
            other.unlock()
 
1323
 
1808
1324
        self.set_bound_location(other.base)
1809
1325
 
1810
1326
    @needs_write_lock
1823
1339
        if master is not None:
1824
1340
            old_tip = self.last_revision()
1825
1341
            self.pull(master, overwrite=True)
1826
 
            if old_tip in self.repository.get_ancestry(
1827
 
                _mod_revision.ensure_null(self.last_revision()),
1828
 
                topo_sorted=False):
 
1342
            if old_tip in self.repository.get_ancestry(self.last_revision()):
1829
1343
                return None
1830
1344
            return old_tip
1831
1345
        return None
1832
1346
 
1833
1347
 
1834
 
class BzrBranchExperimental(BzrBranch5):
1835
 
    """Bzr experimental branch format
1836
 
 
1837
 
    This format has:
1838
 
     - a revision-history file.
1839
 
     - a format string
1840
 
     - a lock dir guarding the branch itself
1841
 
     - all of this stored in a branch/ subdirectory
1842
 
     - works with shared repositories.
1843
 
     - a tag dictionary in the branch
1844
 
 
1845
 
    This format is new in bzr 0.15, but shouldn't be used for real data, 
1846
 
    only for testing.
1847
 
 
1848
 
    This class acts as it's own BranchFormat.
1849
 
    """
1850
 
 
1851
 
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1852
 
 
1853
 
    @classmethod
1854
 
    def get_format_string(cls):
1855
 
        """See BranchFormat.get_format_string()."""
1856
 
        return "Bazaar-NG branch format experimental\n"
1857
 
 
1858
 
    @classmethod
1859
 
    def get_format_description(cls):
1860
 
        """See BranchFormat.get_format_description()."""
1861
 
        return "Experimental branch format"
1862
 
 
1863
 
    @classmethod
1864
 
    def get_reference(cls, a_bzrdir):
1865
 
        """Get the target reference of the branch in a_bzrdir.
1866
 
 
1867
 
        format probing must have been completed before calling
1868
 
        this method - it is assumed that the format of the branch
1869
 
        in a_bzrdir is correct.
1870
 
 
1871
 
        :param a_bzrdir: The bzrdir to get the branch data from.
1872
 
        :return: None if the branch is not a reference branch.
1873
 
        """
1874
 
        return None
1875
 
 
1876
 
    @classmethod
1877
 
    def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1878
 
            lock_class):
1879
 
        branch_transport = a_bzrdir.get_branch_transport(cls)
1880
 
        control_files = lockable_files.LockableFiles(branch_transport,
1881
 
            lock_filename, lock_class)
1882
 
        control_files.create_lock()
1883
 
        control_files.lock_write()
1884
 
        try:
1885
 
            for filename, content in utf8_files:
1886
 
                control_files.put_utf8(filename, content)
1887
 
        finally:
1888
 
            control_files.unlock()
1889
 
        
1890
 
    @classmethod
1891
 
    def initialize(cls, a_bzrdir):
1892
 
        """Create a branch of this format in a_bzrdir."""
1893
 
        utf8_files = [('format', cls.get_format_string()),
1894
 
                      ('revision-history', ''),
1895
 
                      ('branch-name', ''),
1896
 
                      ('tags', ''),
1897
 
                      ]
1898
 
        cls._initialize_control_files(a_bzrdir, utf8_files,
1899
 
            'lock', lockdir.LockDir)
1900
 
        return cls.open(a_bzrdir, _found=True)
1901
 
 
1902
 
    @classmethod
1903
 
    def open(cls, a_bzrdir, _found=False):
1904
 
        """Return the branch object for a_bzrdir
1905
 
 
1906
 
        _found is a private parameter, do not use it. It is used to indicate
1907
 
               if format probing has already be done.
1908
 
        """
1909
 
        if not _found:
1910
 
            format = BranchFormat.find_format(a_bzrdir)
1911
 
            assert format.__class__ == cls
1912
 
        transport = a_bzrdir.get_branch_transport(None)
1913
 
        control_files = lockable_files.LockableFiles(transport, 'lock',
1914
 
                                                     lockdir.LockDir)
1915
 
        return cls(_format=cls,
1916
 
            _control_files=control_files,
1917
 
            a_bzrdir=a_bzrdir,
1918
 
            _repository=a_bzrdir.find_repository())
1919
 
 
1920
 
    @classmethod
1921
 
    def is_supported(cls):
1922
 
        return True
1923
 
 
1924
 
    def _make_tags(self):
1925
 
        return BasicTags(self)
1926
 
 
1927
 
    @classmethod
1928
 
    def supports_tags(cls):
1929
 
        return True
1930
 
 
1931
 
 
1932
 
BranchFormat.register_format(BzrBranchExperimental)
1933
 
 
1934
 
 
1935
 
class BzrBranch6(BzrBranch5):
1936
 
 
1937
 
    @needs_read_lock
1938
 
    def last_revision_info(self):
1939
 
        revision_string = self.control_files.get('last-revision').read()
1940
 
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1941
 
        revision_id = cache_utf8.get_cached_utf8(revision_id)
1942
 
        revno = int(revno)
1943
 
        return revno, revision_id
1944
 
 
1945
 
    def last_revision(self):
1946
 
        """Return last revision id, or None"""
1947
 
        revision_id = self.last_revision_info()[1]
1948
 
        if revision_id == _mod_revision.NULL_REVISION:
1949
 
            revision_id = None
1950
 
        return revision_id
1951
 
 
1952
 
    def _write_last_revision_info(self, revno, revision_id):
1953
 
        """Simply write out the revision id, with no checks.
1954
 
 
1955
 
        Use set_last_revision_info to perform this safely.
1956
 
 
1957
 
        Does not update the revision_history cache.
1958
 
        Intended to be called by set_last_revision_info and
1959
 
        _write_revision_history.
1960
 
        """
1961
 
        if revision_id is None:
1962
 
            revision_id = 'null:'
1963
 
        out_string = '%d %s\n' % (revno, revision_id)
1964
 
        self.control_files.put_bytes('last-revision', out_string)
1965
 
 
1966
 
    @needs_write_lock
1967
 
    def set_last_revision_info(self, revno, revision_id):
1968
 
        revision_id = osutils.safe_revision_id(revision_id)
1969
 
        if self._get_append_revisions_only():
1970
 
            self._check_history_violation(revision_id)
1971
 
        self._write_last_revision_info(revno, revision_id)
1972
 
        self._clear_cached_state()
1973
 
 
1974
 
    def _check_history_violation(self, revision_id):
1975
 
        last_revision = _mod_revision.ensure_null(self.last_revision())
1976
 
        if _mod_revision.is_null(last_revision):
1977
 
            return
1978
 
        if last_revision not in self._lefthand_history(revision_id):
1979
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
1980
 
 
1981
 
    def _gen_revision_history(self):
1982
 
        """Generate the revision history from last revision
1983
 
        """
1984
 
        history = list(self.repository.iter_reverse_revision_history(
1985
 
            self.last_revision()))
1986
 
        history.reverse()
1987
 
        return history
1988
 
 
1989
 
    def _write_revision_history(self, history):
1990
 
        """Factored out of set_revision_history.
1991
 
 
1992
 
        This performs the actual writing to disk, with format-specific checks.
1993
 
        It is intended to be called by BzrBranch5.set_revision_history.
1994
 
        """
1995
 
        if len(history) == 0:
1996
 
            last_revision = 'null:'
1997
 
        else:
1998
 
            if history != self._lefthand_history(history[-1]):
1999
 
                raise errors.NotLefthandHistory(history)
2000
 
            last_revision = history[-1]
2001
 
        if self._get_append_revisions_only():
2002
 
            self._check_history_violation(last_revision)
2003
 
        self._write_last_revision_info(len(history), last_revision)
2004
 
 
2005
 
    @needs_write_lock
2006
 
    def append_revision(self, *revision_ids):
2007
 
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
2008
 
        if len(revision_ids) == 0:
2009
 
            return
2010
 
        prev_revno, prev_revision = self.last_revision_info()
2011
 
        for revision in self.repository.get_revisions(revision_ids):
2012
 
            if prev_revision == _mod_revision.NULL_REVISION:
2013
 
                if revision.parent_ids != []:
2014
 
                    raise errors.NotLeftParentDescendant(self, prev_revision,
2015
 
                                                         revision.revision_id)
2016
 
            else:
2017
 
                if revision.parent_ids[0] != prev_revision:
2018
 
                    raise errors.NotLeftParentDescendant(self, prev_revision,
2019
 
                                                         revision.revision_id)
2020
 
            prev_revision = revision.revision_id
2021
 
        self.set_last_revision_info(prev_revno + len(revision_ids),
2022
 
                                    revision_ids[-1])
2023
 
 
2024
 
    @needs_write_lock
2025
 
    def _set_parent_location(self, url):
2026
 
        """Set the parent branch"""
2027
 
        self._set_config_location('parent_location', url, make_relative=True)
2028
 
 
2029
 
    @needs_read_lock
2030
 
    def _get_parent_location(self):
2031
 
        """Set the parent branch"""
2032
 
        return self._get_config_location('parent_location')
2033
 
 
2034
 
    def set_push_location(self, location):
2035
 
        """See Branch.set_push_location."""
2036
 
        self._set_config_location('push_location', location)
2037
 
 
2038
 
    def set_bound_location(self, location):
2039
 
        """See Branch.set_push_location."""
2040
 
        result = None
2041
 
        config = self.get_config()
2042
 
        if location is None:
2043
 
            if config.get_user_option('bound') != 'True':
2044
 
                return False
2045
 
            else:
2046
 
                config.set_user_option('bound', 'False', warn_masked=True)
2047
 
                return True
2048
 
        else:
2049
 
            self._set_config_location('bound_location', location,
2050
 
                                      config=config)
2051
 
            config.set_user_option('bound', 'True', warn_masked=True)
2052
 
        return True
2053
 
 
2054
 
    def _get_bound_location(self, bound):
2055
 
        """Return the bound location in the config file.
2056
 
 
2057
 
        Return None if the bound parameter does not match"""
2058
 
        config = self.get_config()
2059
 
        config_bound = (config.get_user_option('bound') == 'True')
2060
 
        if config_bound != bound:
2061
 
            return None
2062
 
        return self._get_config_location('bound_location', config=config)
2063
 
 
2064
 
    def get_bound_location(self):
2065
 
        """See Branch.set_push_location."""
2066
 
        return self._get_bound_location(True)
2067
 
 
2068
 
    def get_old_bound_location(self):
2069
 
        """See Branch.get_old_bound_location"""
2070
 
        return self._get_bound_location(False)
2071
 
 
2072
 
    def set_append_revisions_only(self, enabled):
2073
 
        if enabled:
2074
 
            value = 'True'
2075
 
        else:
2076
 
            value = 'False'
2077
 
        self.get_config().set_user_option('append_revisions_only', value,
2078
 
            warn_masked=True)
2079
 
 
2080
 
    def _get_append_revisions_only(self):
2081
 
        value = self.get_config().get_user_option('append_revisions_only')
2082
 
        return value == 'True'
2083
 
 
2084
 
    def _synchronize_history(self, destination, revision_id):
2085
 
        """Synchronize last revision and revision history between branches.
2086
 
 
2087
 
        This version is most efficient when the destination is also a
2088
 
        BzrBranch6, but works for BzrBranch5, as long as the destination's
2089
 
        repository contains all the lefthand ancestors of the intended
2090
 
        last_revision.  If not, set_last_revision_info will fail.
2091
 
 
2092
 
        :param destination: The branch to copy the history into
2093
 
        :param revision_id: The revision-id to truncate history at.  May
2094
 
          be None to copy complete history.
2095
 
        """
2096
 
        if revision_id is None:
2097
 
            revno, revision_id = self.last_revision_info()
2098
 
        else:
2099
 
            # To figure out the revno for a random revision, we need to build
2100
 
            # the revision history, and count its length.
2101
 
            # We don't care about the order, just how long it is.
2102
 
            # Alternatively, we could start at the current location, and count
2103
 
            # backwards. But there is no guarantee that we will find it since
2104
 
            # it may be a merged revision.
2105
 
            revno = len(list(self.repository.iter_reverse_revision_history(
2106
 
                                                                revision_id)))
2107
 
        destination.set_last_revision_info(revno, revision_id)
2108
 
 
2109
 
    def _make_tags(self):
2110
 
        return BasicTags(self)
2111
 
 
2112
 
 
2113
 
######################################################################
2114
 
# results of operations
2115
 
 
2116
 
 
2117
 
class _Result(object):
2118
 
 
2119
 
    def _show_tag_conficts(self, to_file):
2120
 
        if not getattr(self, 'tag_conflicts', None):
2121
 
            return
2122
 
        to_file.write('Conflicting tags:\n')
2123
 
        for name, value1, value2 in self.tag_conflicts:
2124
 
            to_file.write('    %s\n' % (name, ))
2125
 
 
2126
 
 
2127
 
class PullResult(_Result):
2128
 
    """Result of a Branch.pull operation.
2129
 
 
2130
 
    :ivar old_revno: Revision number before pull.
2131
 
    :ivar new_revno: Revision number after pull.
2132
 
    :ivar old_revid: Tip revision id before pull.
2133
 
    :ivar new_revid: Tip revision id after pull.
2134
 
    :ivar source_branch: Source (local) branch object.
2135
 
    :ivar master_branch: Master branch of the target, or None.
2136
 
    :ivar target_branch: Target/destination branch object.
2137
 
    """
2138
 
 
2139
 
    def __int__(self):
2140
 
        # DEPRECATED: pull used to return the change in revno
2141
 
        return self.new_revno - self.old_revno
2142
 
 
2143
 
    def report(self, to_file):
2144
 
        if self.old_revid == self.new_revid:
2145
 
            to_file.write('No revisions to pull.\n')
2146
 
        else:
2147
 
            to_file.write('Now on revision %d.\n' % self.new_revno)
2148
 
        self._show_tag_conficts(to_file)
2149
 
 
2150
 
 
2151
 
class PushResult(_Result):
2152
 
    """Result of a Branch.push operation.
2153
 
 
2154
 
    :ivar old_revno: Revision number before push.
2155
 
    :ivar new_revno: Revision number after push.
2156
 
    :ivar old_revid: Tip revision id before push.
2157
 
    :ivar new_revid: Tip revision id after push.
2158
 
    :ivar source_branch: Source branch object.
2159
 
    :ivar master_branch: Master branch of the target, or None.
2160
 
    :ivar target_branch: Target/destination branch object.
2161
 
    """
2162
 
 
2163
 
    def __int__(self):
2164
 
        # DEPRECATED: push used to return the change in revno
2165
 
        return self.new_revno - self.old_revno
2166
 
 
2167
 
    def report(self, to_file):
2168
 
        """Write a human-readable description of the result."""
2169
 
        if self.old_revid == self.new_revid:
2170
 
            to_file.write('No new revisions to push.\n')
2171
 
        else:
2172
 
            to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2173
 
        self._show_tag_conficts(to_file)
 
1348
class BranchTestProviderAdapter(object):
 
1349
    """A tool to generate a suite testing multiple branch formats at once.
 
1350
 
 
1351
    This is done by copying the test once for each transport and injecting
 
1352
    the transport_server, transport_readonly_server, and branch_format
 
1353
    classes into each copy. Each copy is also given a new id() to make it
 
1354
    easy to identify.
 
1355
    """
 
1356
 
 
1357
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1358
        self._transport_server = transport_server
 
1359
        self._transport_readonly_server = transport_readonly_server
 
1360
        self._formats = formats
 
1361
    
 
1362
    def adapt(self, test):
 
1363
        result = TestSuite()
 
1364
        for branch_format, bzrdir_format in self._formats:
 
1365
            new_test = deepcopy(test)
 
1366
            new_test.transport_server = self._transport_server
 
1367
            new_test.transport_readonly_server = self._transport_readonly_server
 
1368
            new_test.bzrdir_format = bzrdir_format
 
1369
            new_test.branch_format = branch_format
 
1370
            def make_new_test_id():
 
1371
                new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
 
1372
                return lambda: new_id
 
1373
            new_test.id = make_new_test_id()
 
1374
            result.addTest(new_test)
 
1375
        return result
2174
1376
 
2175
1377
 
2176
1378
class BranchCheckResult(object):
2193
1395
             self.branch._format)
2194
1396
 
2195
1397
 
2196
 
class Converter5to6(object):
2197
 
    """Perform an in-place upgrade of format 5 to format 6"""
2198
 
 
2199
 
    def convert(self, branch):
2200
 
        # Data for 5 and 6 can peacefully coexist.
2201
 
        format = BzrBranchFormat6()
2202
 
        new_branch = format.open(branch.bzrdir, _found=True)
2203
 
 
2204
 
        # Copy source data into target
2205
 
        new_branch.set_last_revision_info(*branch.last_revision_info())
2206
 
        new_branch.set_parent(branch.get_parent())
2207
 
        new_branch.set_bound_location(branch.get_bound_location())
2208
 
        new_branch.set_push_location(branch.get_push_location())
2209
 
 
2210
 
        # New branch has no tags by default
2211
 
        new_branch.tags._set_tag_dict({})
2212
 
 
2213
 
        # Copying done; now update target format
2214
 
        new_branch.control_files.put_utf8('format',
2215
 
            format.get_format_string())
2216
 
 
2217
 
        # Clean up old files
2218
 
        new_branch.control_files._transport.delete('revision-history')
2219
 
        try:
2220
 
            branch.set_parent(None)
2221
 
        except NoSuchFile:
2222
 
            pass
2223
 
        branch.set_bound_location(None)
 
1398
######################################################################
 
1399
# predicates
 
1400
 
 
1401
 
 
1402
@deprecated_function(zero_eight)
 
1403
def is_control_file(*args, **kwargs):
 
1404
    """See bzrlib.workingtree.is_control_file."""
 
1405
    return bzrlib.workingtree.is_control_file(*args, **kwargs)