~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Ian Clatworthy
  • Date: 2009-01-19 02:24:15 UTC
  • mto: This revision was merged to the branch mainline in revision 3944.
  • Revision ID: ian.clatworthy@canonical.com-20090119022415-mo0mcfeiexfktgwt
apply jam's log --short fix (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
19
 
from cStringIO import StringIO
20
 
import errno
21
 
import os
22
 
import shutil
23
18
import sys
24
 
from unittest import TestSuite
25
 
from warnings import warn
26
 
 
27
 
import bzrlib
28
 
import bzrlib.bzrdir as bzrdir
29
 
from bzrlib.config import TreeConfig
 
19
 
 
20
from bzrlib.lazy_import import lazy_import
 
21
lazy_import(globals(), """
 
22
from itertools import chain
 
23
from bzrlib import (
 
24
        bzrdir,
 
25
        cache_utf8,
 
26
        config as _mod_config,
 
27
        debug,
 
28
        errors,
 
29
        lockdir,
 
30
        lockable_files,
 
31
        repository,
 
32
        revision as _mod_revision,
 
33
        transport,
 
34
        tsort,
 
35
        ui,
 
36
        urlutils,
 
37
        )
 
38
from bzrlib.config import BranchConfig
 
39
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
 
40
from bzrlib.tag import (
 
41
    BasicTags,
 
42
    DisabledTags,
 
43
    )
 
44
""")
 
45
 
30
46
from bzrlib.decorators import needs_read_lock, needs_write_lock
31
 
from bzrlib.delta import compare_trees
32
 
import bzrlib.errors as errors
33
 
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
34
 
                           NoSuchRevision, HistoryMissing, NotBranchError,
35
 
                           DivergedBranches, LockError,
36
 
                           UninitializableFormat,
37
 
                           UnlistableStore,
38
 
                           UnlistableBranch, NoSuchFile, NotVersionedError,
39
 
                           NoWorkingTree)
40
 
import bzrlib.inventory as inventory
41
 
from bzrlib.inventory import Inventory
42
 
from bzrlib.lockable_files import LockableFiles, TransportLock
43
 
from bzrlib.lockdir import LockDir
44
 
from bzrlib.osutils import (isdir, quotefn,
45
 
                            rename, splitpath, sha_file,
46
 
                            file_kind, abspath, normpath, pathjoin,
47
 
                            safe_unicode,
48
 
                            rmtree,
49
 
                            )
50
 
from bzrlib.repository import Repository
51
 
from bzrlib.revision import (
52
 
                             is_ancestor,
53
 
                             NULL_REVISION,
54
 
                             Revision,
55
 
                             )
56
 
from bzrlib.store import copy_all
57
 
from bzrlib.symbol_versioning import *
58
 
from bzrlib.textui import show_status
59
 
from bzrlib.trace import mutter, note
60
 
import bzrlib.transactions as transactions
61
 
from bzrlib.transport import Transport, get_transport
62
 
from bzrlib.tree import EmptyTree, RevisionTree
63
 
import bzrlib.ui
64
 
import bzrlib.urlutils as urlutils
65
 
import bzrlib.xml5
 
47
from bzrlib.hooks import Hooks
 
48
from bzrlib.symbol_versioning import (
 
49
    deprecated_in,
 
50
    deprecated_method,
 
51
    )
 
52
from bzrlib.trace import mutter, mutter_callsite, note, is_quiet
66
53
 
67
54
 
68
55
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
69
56
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
70
 
BZR_BRANCH_FORMAT_6 = "Bazaar-NG branch, format 6\n"
 
57
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
71
58
 
72
59
 
73
60
# TODO: Maybe include checks for common corruption of newlines, etc?
87
74
 
88
75
    base
89
76
        Base directory/url of the branch.
 
77
 
 
78
    hooks: An instance of BranchHooks.
90
79
    """
91
80
    # this is really an instance variable - FIXME move it there
92
81
    # - RBC 20060112
93
82
    base = None
94
83
 
 
84
    # override this to set the strategy for storing tags
 
85
    def _make_tags(self):
 
86
        return DisabledTags(self)
 
87
 
95
88
    def __init__(self, *ignored, **ignored_too):
96
 
        raise NotImplementedError('The Branch class is abstract')
 
89
        self.tags = self._make_tags()
 
90
        self._revision_history_cache = None
 
91
        self._revision_id_to_revno_cache = None
 
92
        self._last_revision_info_cache = None
 
93
        self._open_hook()
 
94
        hooks = Branch.hooks['open']
 
95
        for hook in hooks:
 
96
            hook(self)
 
97
 
 
98
    def _open_hook(self):
 
99
        """Called by init to allow simpler extension of the base class."""
97
100
 
98
101
    def break_lock(self):
99
102
        """Break a lock if one is present from another instance.
110
113
            master.break_lock()
111
114
 
112
115
    @staticmethod
113
 
    @deprecated_method(zero_eight)
114
 
    def open_downlevel(base):
115
 
        """Open a branch which may be of an old format."""
116
 
        return Branch.open(base, _unsupported=True)
117
 
        
118
 
    @staticmethod
119
 
    def open(base, _unsupported=False):
120
 
        """Open the repository rooted at base.
 
116
    def open(base, _unsupported=False, possible_transports=None):
 
117
        """Open the branch rooted at base.
121
118
 
122
 
        For instance, if the repository is at URL/.bzr/repository,
123
 
        Repository.open(URL) -> a Repository instance.
 
119
        For instance, if the branch is at URL/.bzr/branch,
 
120
        Branch.open(URL) -> a Branch instance.
124
121
        """
125
 
        control = bzrdir.BzrDir.open(base, _unsupported)
126
 
        return control.open_branch(_unsupported)
127
 
 
128
 
    @staticmethod
129
 
    def open_containing(url):
 
122
        control = bzrdir.BzrDir.open(base, _unsupported,
 
123
                                     possible_transports=possible_transports)
 
124
        return control.open_branch(_unsupported)
 
125
 
 
126
    @staticmethod
 
127
    def open_from_transport(transport, _unsupported=False):
 
128
        """Open the branch rooted at transport"""
 
129
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
 
130
        return control.open_branch(_unsupported)
 
131
 
 
132
    @staticmethod
 
133
    def open_containing(url, possible_transports=None):
130
134
        """Open an existing branch which contains url.
131
135
        
132
136
        This probes for a branch at url, and searches upwards from there.
137
141
        format, UnknownFormatError or UnsupportedFormatError are raised.
138
142
        If there is one, it is returned, along with the unused portion of url.
139
143
        """
140
 
        control, relpath = bzrdir.BzrDir.open_containing(url)
 
144
        control, relpath = bzrdir.BzrDir.open_containing(url,
 
145
                                                         possible_transports)
141
146
        return control.open_branch(), relpath
142
147
 
143
 
    @staticmethod
144
 
    @deprecated_function(zero_eight)
145
 
    def initialize(base):
146
 
        """Create a new working tree and branch, rooted at 'base' (url)
147
 
 
148
 
        NOTE: This will soon be deprecated in favour of creation
149
 
        through a BzrDir.
150
 
        """
151
 
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
152
 
 
153
 
    def setup_caching(self, cache_root):
154
 
        """Subclasses that care about caching should override this, and set
155
 
        up cached stores located under cache_root.
156
 
        """
157
 
        # seems to be unused, 2006-01-13 mbp
158
 
        warn('%s is deprecated' % self.setup_caching)
159
 
        self.cache_root = cache_root
160
 
 
161
 
    def _get_nick(self):
162
 
        cfg = self.tree_config()
163
 
        return cfg.get_option(u"nickname", default=self.base.split('/')[-2])
 
148
    def get_config(self):
 
149
        return BranchConfig(self)
 
150
 
 
151
    def _get_nick(self, local=False, possible_transports=None):
 
152
        config = self.get_config()
 
153
        # explicit overrides master, but don't look for master if local is True
 
154
        if not local and not config.has_explicit_nickname():
 
155
            try:
 
156
                master = self.get_master_branch(possible_transports)
 
157
                if master is not None:
 
158
                    # return the master branch value
 
159
                    return master.nick
 
160
            except errors.BzrError, e:
 
161
                # Silently fall back to local implicit nick if the master is
 
162
                # unavailable
 
163
                mutter("Could not connect to bound branch, "
 
164
                    "falling back to local nick.\n " + str(e))
 
165
        return config.get_nickname()
164
166
 
165
167
    def _set_nick(self, nick):
166
 
        cfg = self.tree_config()
167
 
        cfg.set_option(nick, "nickname")
168
 
        assert cfg.get_option("nickname") == nick
 
168
        self.get_config().set_user_option('nickname', nick, warn_masked=True)
169
169
 
170
170
    nick = property(_get_nick, _set_nick)
171
171
 
172
172
    def is_locked(self):
173
 
        raise NotImplementedError('is_locked is abstract')
 
173
        raise NotImplementedError(self.is_locked)
174
174
 
175
175
    def lock_write(self):
176
 
        raise NotImplementedError('lock_write is abstract')
 
176
        raise NotImplementedError(self.lock_write)
177
177
 
178
178
    def lock_read(self):
179
 
        raise NotImplementedError('lock_read is abstract')
 
179
        raise NotImplementedError(self.lock_read)
180
180
 
181
181
    def unlock(self):
182
 
        raise NotImplementedError('unlock is abstract')
 
182
        raise NotImplementedError(self.unlock)
183
183
 
184
184
    def peek_lock_mode(self):
185
185
        """Return lock mode for the Branch: 'r', 'w' or None"""
186
186
        raise NotImplementedError(self.peek_lock_mode)
187
187
 
188
188
    def get_physical_lock_status(self):
189
 
        raise NotImplementedError('get_physical_lock_status is abstract')
190
 
 
191
 
    def abspath(self, name):
192
 
        """Return absolute filename for something in the branch
 
189
        raise NotImplementedError(self.get_physical_lock_status)
 
190
 
 
191
    @needs_read_lock
 
192
    def get_revision_id_to_revno_map(self):
 
193
        """Return the revision_id => dotted revno map.
 
194
 
 
195
        This will be regenerated on demand, but will be cached.
 
196
 
 
197
        :return: A dictionary mapping revision_id => dotted revno.
 
198
            This dictionary should not be modified by the caller.
 
199
        """
 
200
        if self._revision_id_to_revno_cache is not None:
 
201
            mapping = self._revision_id_to_revno_cache
 
202
        else:
 
203
            mapping = self._gen_revno_map()
 
204
            self._cache_revision_id_to_revno(mapping)
 
205
        # TODO: jam 20070417 Since this is being cached, should we be returning
 
206
        #       a copy?
 
207
        # I would rather not, and instead just declare that users should not
 
208
        # modify the return value.
 
209
        return mapping
 
210
 
 
211
    def _gen_revno_map(self):
 
212
        """Create a new mapping from revision ids to dotted revnos.
 
213
 
 
214
        Dotted revnos are generated based on the current tip in the revision
 
215
        history.
 
216
        This is the worker function for get_revision_id_to_revno_map, which
 
217
        just caches the return value.
 
218
 
 
219
        :return: A dictionary mapping revision_id => dotted revno.
 
220
        """
 
221
        last_revision = self.last_revision()
 
222
        revision_graph = repository._old_get_graph(self.repository,
 
223
            last_revision)
 
224
        merge_sorted_revisions = tsort.merge_sort(
 
225
            revision_graph,
 
226
            last_revision,
 
227
            None,
 
228
            generate_revno=True)
 
229
        revision_id_to_revno = dict((rev_id, revno)
 
230
                                    for seq_num, rev_id, depth, revno, end_of_merge
 
231
                                     in merge_sorted_revisions)
 
232
        return revision_id_to_revno
 
233
 
 
234
    def leave_lock_in_place(self):
 
235
        """Tell this branch object not to release the physical lock when this
 
236
        object is unlocked.
193
237
        
194
 
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
195
 
        method and not a tree method.
196
 
        """
197
 
        raise NotImplementedError('abspath is abstract')
 
238
        If lock_write doesn't return a token, then this method is not supported.
 
239
        """
 
240
        self.control_files.leave_in_place()
 
241
 
 
242
    def dont_leave_lock_in_place(self):
 
243
        """Tell this branch object to release the physical lock when this
 
244
        object is unlocked, even if it didn't originally acquire it.
 
245
 
 
246
        If lock_write doesn't return a token, then this method is not supported.
 
247
        """
 
248
        self.control_files.dont_leave_in_place()
198
249
 
199
250
    def bind(self, other):
200
251
        """Bind the local branch the other branch.
219
270
        if self.base == from_branch.base:
220
271
            return (0, [])
221
272
        if pb is None:
222
 
            nested_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
273
            nested_pb = ui.ui_factory.nested_progress_bar()
223
274
            pb = nested_pb
224
275
        else:
225
276
            nested_pb = None
228
279
        try:
229
280
            if last_revision is None:
230
281
                pb.update('get source history')
231
 
                from_history = from_branch.revision_history()
232
 
                if from_history:
233
 
                    last_revision = from_history[-1]
234
 
                else:
235
 
                    # no history in the source branch
236
 
                    last_revision = NULL_REVISION
 
282
                last_revision = from_branch.last_revision()
 
283
                last_revision = _mod_revision.ensure_null(last_revision)
237
284
            return self.repository.fetch(from_branch.repository,
238
285
                                         revision_id=last_revision,
239
286
                                         pb=nested_pb)
250
297
        """
251
298
        return None
252
299
    
 
300
    def get_old_bound_location(self):
 
301
        """Return the URL of the branch we used to be bound to
 
302
        """
 
303
        raise errors.UpgradeRequired(self.base)
 
304
 
253
305
    def get_commit_builder(self, parents, config=None, timestamp=None, 
254
306
                           timezone=None, committer=None, revprops=None, 
255
307
                           revision_id=None):
265
317
        """
266
318
 
267
319
        if config is None:
268
 
            config = bzrlib.config.BranchConfig(self)
 
320
            config = self.get_config()
269
321
        
270
 
        return self.repository.get_commit_builder(self, parents, config, 
 
322
        return self.repository.get_commit_builder(self, parents, config,
271
323
            timestamp, timezone, committer, revprops, revision_id)
272
324
 
273
 
    def get_master_branch(self):
 
325
    def get_master_branch(self, possible_transports=None):
274
326
        """Return the branch we are bound to.
275
327
        
276
328
        :return: Either a Branch, or None
277
329
        """
278
330
        return None
279
331
 
280
 
    def get_root_id(self):
281
 
        """Return the id of this branches root"""
282
 
        raise NotImplementedError('get_root_id is abstract')
 
332
    def get_revision_delta(self, revno):
 
333
        """Return the delta for one revision.
 
334
 
 
335
        The delta is relative to its mainline predecessor, or the
 
336
        empty tree for revision 1.
 
337
        """
 
338
        rh = self.revision_history()
 
339
        if not (1 <= revno <= len(rh)):
 
340
            raise errors.InvalidRevisionNumber(revno)
 
341
        return self.repository.get_revision_delta(rh[revno-1])
 
342
 
 
343
    def get_stacked_on_url(self):
 
344
        """Get the URL this branch is stacked against.
 
345
 
 
346
        :raises NotStacked: If the branch is not stacked.
 
347
        :raises UnstackableBranchFormat: If the branch does not support
 
348
            stacking.
 
349
        """
 
350
        raise NotImplementedError(self.get_stacked_on_url)
283
351
 
284
352
    def print_file(self, file, revision_id):
285
353
        """Print `file` to stdout."""
286
 
        raise NotImplementedError('print_file is abstract')
287
 
 
288
 
    def append_revision(self, *revision_ids):
289
 
        raise NotImplementedError('append_revision is abstract')
 
354
        raise NotImplementedError(self.print_file)
290
355
 
291
356
    def set_revision_history(self, rev_history):
292
 
        raise NotImplementedError('set_revision_history is abstract')
293
 
 
 
357
        raise NotImplementedError(self.set_revision_history)
 
358
 
 
359
    def set_stacked_on_url(self, url):
 
360
        """Set the URL this branch is stacked against.
 
361
 
 
362
        :raises UnstackableBranchFormat: If the branch does not support
 
363
            stacking.
 
364
        :raises UnstackableRepositoryFormat: If the repository does not support
 
365
            stacking.
 
366
        """
 
367
        raise NotImplementedError(self.set_stacked_on_url)
 
368
 
 
369
    def _cache_revision_history(self, rev_history):
 
370
        """Set the cached revision history to rev_history.
 
371
 
 
372
        The revision_history method will use this cache to avoid regenerating
 
373
        the revision history.
 
374
 
 
375
        This API is semi-public; it only for use by subclasses, all other code
 
376
        should consider it to be private.
 
377
        """
 
378
        self._revision_history_cache = rev_history
 
379
 
 
380
    def _cache_revision_id_to_revno(self, revision_id_to_revno):
 
381
        """Set the cached revision_id => revno map to revision_id_to_revno.
 
382
 
 
383
        This API is semi-public; it only for use by subclasses, all other code
 
384
        should consider it to be private.
 
385
        """
 
386
        self._revision_id_to_revno_cache = revision_id_to_revno
 
387
 
 
388
    def _clear_cached_state(self):
 
389
        """Clear any cached data on this branch, e.g. cached revision history.
 
390
 
 
391
        This means the next call to revision_history will need to call
 
392
        _gen_revision_history.
 
393
 
 
394
        This API is semi-public; it only for use by subclasses, all other code
 
395
        should consider it to be private.
 
396
        """
 
397
        self._revision_history_cache = None
 
398
        self._revision_id_to_revno_cache = None
 
399
        self._last_revision_info_cache = None
 
400
 
 
401
    def _gen_revision_history(self):
 
402
        """Return sequence of revision hashes on to this branch.
 
403
        
 
404
        Unlike revision_history, this method always regenerates or rereads the
 
405
        revision history, i.e. it does not cache the result, so repeated calls
 
406
        may be expensive.
 
407
 
 
408
        Concrete subclasses should override this instead of revision_history so
 
409
        that subclasses do not need to deal with caching logic.
 
410
        
 
411
        This API is semi-public; it only for use by subclasses, all other code
 
412
        should consider it to be private.
 
413
        """
 
414
        raise NotImplementedError(self._gen_revision_history)
 
415
 
 
416
    @needs_read_lock
294
417
    def revision_history(self):
295
 
        """Return sequence of revision hashes on to this branch."""
296
 
        raise NotImplementedError('revision_history is abstract')
 
418
        """Return sequence of revision ids on this branch.
 
419
        
 
420
        This method will cache the revision history for as long as it is safe to
 
421
        do so.
 
422
        """
 
423
        if 'evil' in debug.debug_flags:
 
424
            mutter_callsite(3, "revision_history scales with history.")
 
425
        if self._revision_history_cache is not None:
 
426
            history = self._revision_history_cache
 
427
        else:
 
428
            history = self._gen_revision_history()
 
429
            self._cache_revision_history(history)
 
430
        return list(history)
297
431
 
298
432
    def revno(self):
299
433
        """Return current revision number for this branch.
301
435
        That is equivalent to the number of revisions committed to
302
436
        this branch.
303
437
        """
304
 
        return len(self.revision_history())
 
438
        return self.last_revision_info()[0]
305
439
 
306
440
    def unbind(self):
307
441
        """Older format branches cannot bind or unbind."""
308
442
        raise errors.UpgradeRequired(self.base)
309
443
 
 
444
    def set_append_revisions_only(self, enabled):
 
445
        """Older format branches are never restricted to append-only"""
 
446
        raise errors.UpgradeRequired(self.base)
 
447
 
310
448
    def last_revision(self):
311
 
        """Return last patch hash, or None if no history."""
312
 
        ph = self.revision_history()
313
 
        if ph:
314
 
            return ph[-1]
 
449
        """Return last revision id, or NULL_REVISION."""
 
450
        return self.last_revision_info()[1]
 
451
 
 
452
    @needs_read_lock
 
453
    def last_revision_info(self):
 
454
        """Return information about the last revision.
 
455
 
 
456
        :return: A tuple (revno, revision_id).
 
457
        """
 
458
        if self._last_revision_info_cache is None:
 
459
            self._last_revision_info_cache = self._last_revision_info()
 
460
        return self._last_revision_info_cache
 
461
 
 
462
    def _last_revision_info(self):
 
463
        rh = self.revision_history()
 
464
        revno = len(rh)
 
465
        if revno:
 
466
            return (revno, rh[-1])
315
467
        else:
316
 
            return None
 
468
            return (0, _mod_revision.NULL_REVISION)
317
469
 
 
470
    @deprecated_method(deprecated_in((1, 6, 0)))
318
471
    def missing_revisions(self, other, stop_revision=None):
319
472
        """Return a list of new revisions that would perfectly fit.
320
473
        
321
474
        If self and other have not diverged, return a list of the revisions
322
475
        present in other, but missing from self.
323
 
 
324
 
        >>> from bzrlib.workingtree import WorkingTree
325
 
        >>> bzrlib.trace.silent = True
326
 
        >>> d1 = bzrdir.ScratchDir()
327
 
        >>> br1 = d1.open_branch()
328
 
        >>> wt1 = d1.open_workingtree()
329
 
        >>> d2 = bzrdir.ScratchDir()
330
 
        >>> br2 = d2.open_branch()
331
 
        >>> wt2 = d2.open_workingtree()
332
 
        >>> br1.missing_revisions(br2)
333
 
        []
334
 
        >>> wt2.commit("lala!", rev_id="REVISION-ID-1")
335
 
        >>> br1.missing_revisions(br2)
336
 
        [u'REVISION-ID-1']
337
 
        >>> br2.missing_revisions(br1)
338
 
        []
339
 
        >>> wt1.commit("lala!", rev_id="REVISION-ID-1")
340
 
        >>> br1.missing_revisions(br2)
341
 
        []
342
 
        >>> wt2.commit("lala!", rev_id="REVISION-ID-2A")
343
 
        >>> br1.missing_revisions(br2)
344
 
        [u'REVISION-ID-2A']
345
 
        >>> wt1.commit("lala!", rev_id="REVISION-ID-2B")
346
 
        >>> br1.missing_revisions(br2)
347
 
        Traceback (most recent call last):
348
 
        DivergedBranches: These branches have diverged.  Try merge.
349
476
        """
350
477
        self_history = self.revision_history()
351
478
        self_len = len(self_history)
354
481
        common_index = min(self_len, other_len) -1
355
482
        if common_index >= 0 and \
356
483
            self_history[common_index] != other_history[common_index]:
357
 
            raise DivergedBranches(self, other)
 
484
            raise errors.DivergedBranches(self, other)
358
485
 
359
486
        if stop_revision is None:
360
487
            stop_revision = other_len
361
488
        else:
362
 
            assert isinstance(stop_revision, int)
363
489
            if stop_revision > other_len:
364
 
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
 
490
                raise errors.NoSuchRevision(self, stop_revision)
365
491
        return other_history[self_len:stop_revision]
366
492
 
367
 
    def update_revisions(self, other, stop_revision=None):
 
493
    @needs_write_lock
 
494
    def update_revisions(self, other, stop_revision=None, overwrite=False,
 
495
                         graph=None):
368
496
        """Pull in new perfect-fit revisions.
369
497
 
370
498
        :param other: Another Branch to pull from
371
499
        :param stop_revision: Updated until the given revision
 
500
        :param overwrite: Always set the branch pointer, rather than checking
 
501
            to see if it is a proper descendant.
 
502
        :param graph: A Graph object that can be used to query history
 
503
            information. This can be None.
372
504
        :return: None
373
505
        """
374
 
        raise NotImplementedError('update_revisions is abstract')
 
506
        other.lock_read()
 
507
        try:
 
508
            other_revno, other_last_revision = other.last_revision_info()
 
509
            stop_revno = None # unknown
 
510
            if stop_revision is None:
 
511
                stop_revision = other_last_revision
 
512
                if _mod_revision.is_null(stop_revision):
 
513
                    # if there are no commits, we're done.
 
514
                    return
 
515
                stop_revno = other_revno
 
516
 
 
517
            # what's the current last revision, before we fetch [and change it
 
518
            # possibly]
 
519
            last_rev = _mod_revision.ensure_null(self.last_revision())
 
520
            # we fetch here so that we don't process data twice in the common
 
521
            # case of having something to pull, and so that the check for 
 
522
            # already merged can operate on the just fetched graph, which will
 
523
            # be cached in memory.
 
524
            self.fetch(other, stop_revision)
 
525
            # Check to see if one is an ancestor of the other
 
526
            if not overwrite:
 
527
                if graph is None:
 
528
                    graph = self.repository.get_graph()
 
529
                if self._check_if_descendant_or_diverged(
 
530
                        stop_revision, last_rev, graph, other):
 
531
                    # stop_revision is a descendant of last_rev, but we aren't
 
532
                    # overwriting, so we're done.
 
533
                    return
 
534
            if stop_revno is None:
 
535
                if graph is None:
 
536
                    graph = self.repository.get_graph()
 
537
                this_revno, this_last_revision = self.last_revision_info()
 
538
                stop_revno = graph.find_distance_to_null(stop_revision,
 
539
                                [(other_last_revision, other_revno),
 
540
                                 (this_last_revision, this_revno)])
 
541
            self.set_last_revision_info(stop_revno, stop_revision)
 
542
        finally:
 
543
            other.unlock()
375
544
 
376
545
    def revision_id_to_revno(self, revision_id):
377
546
        """Given a revision id, return its revno"""
378
 
        if revision_id is None:
 
547
        if _mod_revision.is_null(revision_id):
379
548
            return 0
380
549
        history = self.revision_history()
381
550
        try:
382
551
            return history.index(revision_id) + 1
383
552
        except ValueError:
384
 
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
553
            raise errors.NoSuchRevision(self, revision_id)
385
554
 
386
555
    def get_rev_id(self, revno, history=None):
387
556
        """Find the revision id of the specified revno."""
388
557
        if revno == 0:
389
 
            return None
 
558
            return _mod_revision.NULL_REVISION
390
559
        if history is None:
391
560
            history = self.revision_history()
392
 
        elif revno <= 0 or revno > len(history):
393
 
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
561
        if revno <= 0 or revno > len(history):
 
562
            raise errors.NoSuchRevision(self, revno)
394
563
        return history[revno - 1]
395
564
 
396
 
    def pull(self, source, overwrite=False, stop_revision=None):
397
 
        raise NotImplementedError('pull is abstract')
 
565
    def pull(self, source, overwrite=False, stop_revision=None,
 
566
             possible_transports=None, _override_hook_target=None):
 
567
        """Mirror source into this branch.
 
568
 
 
569
        This branch is considered to be 'local', having low latency.
 
570
 
 
571
        :returns: PullResult instance
 
572
        """
 
573
        raise NotImplementedError(self.pull)
 
574
 
 
575
    def push(self, target, overwrite=False, stop_revision=None):
 
576
        """Mirror this branch into target.
 
577
 
 
578
        This branch is considered to be 'local', having low latency.
 
579
        """
 
580
        raise NotImplementedError(self.push)
398
581
 
399
582
    def basis_tree(self):
400
 
        """Return `Tree` object for last revision.
401
 
 
402
 
        If there are no revisions yet, return an `EmptyTree`.
403
 
        """
 
583
        """Return `Tree` object for last revision."""
404
584
        return self.repository.revision_tree(self.last_revision())
405
585
 
406
 
    def rename_one(self, from_rel, to_rel):
407
 
        """Rename one file.
408
 
 
409
 
        This can change the directory or the filename or both.
410
 
        """
411
 
        raise NotImplementedError('rename_one is abstract')
412
 
 
413
 
    def move(self, from_paths, to_name):
414
 
        """Rename files.
415
 
 
416
 
        to_name must exist as a versioned directory.
417
 
 
418
 
        If to_name exists and is a directory, the files are moved into
419
 
        it, keeping their old names.  If it is a directory, 
420
 
 
421
 
        Note that to_name is only the last component of the new name;
422
 
        this doesn't change the directory.
423
 
 
424
 
        This returns a list of (from_path, to_path) pairs for each
425
 
        entry that is moved.
426
 
        """
427
 
        raise NotImplementedError('move is abstract')
428
 
 
429
586
    def get_parent(self):
430
587
        """Return the parent location of the branch.
431
588
 
433
590
        pattern is that the user can override it by specifying a
434
591
        location.
435
592
        """
436
 
        raise NotImplementedError('get_parent is abstract')
 
593
        raise NotImplementedError(self.get_parent)
 
594
 
 
595
    def _set_config_location(self, name, url, config=None,
 
596
                             make_relative=False):
 
597
        if config is None:
 
598
            config = self.get_config()
 
599
        if url is None:
 
600
            url = ''
 
601
        elif make_relative:
 
602
            url = urlutils.relative_url(self.base, url)
 
603
        config.set_user_option(name, url, warn_masked=True)
 
604
 
 
605
    def _get_config_location(self, name, config=None):
 
606
        if config is None:
 
607
            config = self.get_config()
 
608
        location = config.get_user_option(name)
 
609
        if location == '':
 
610
            location = None
 
611
        return location
 
612
 
 
613
    def get_submit_branch(self):
 
614
        """Return the submit location of the branch.
 
615
 
 
616
        This is the default location for bundle.  The usual
 
617
        pattern is that the user can override it by specifying a
 
618
        location.
 
619
        """
 
620
        return self.get_config().get_user_option('submit_branch')
 
621
 
 
622
    def set_submit_branch(self, location):
 
623
        """Return the submit location of the branch.
 
624
 
 
625
        This is the default location for bundle.  The usual
 
626
        pattern is that the user can override it by specifying a
 
627
        location.
 
628
        """
 
629
        self.get_config().set_user_option('submit_branch', location,
 
630
            warn_masked=True)
 
631
 
 
632
    def get_public_branch(self):
 
633
        """Return the public location of the branch.
 
634
 
 
635
        This is is used by merge directives.
 
636
        """
 
637
        return self._get_config_location('public_branch')
 
638
 
 
639
    def set_public_branch(self, location):
 
640
        """Return the submit location of the branch.
 
641
 
 
642
        This is the default location for bundle.  The usual
 
643
        pattern is that the user can override it by specifying a
 
644
        location.
 
645
        """
 
646
        self._set_config_location('public_branch', location)
437
647
 
438
648
    def get_push_location(self):
439
649
        """Return the None or the location to push this branch to."""
440
 
        raise NotImplementedError('get_push_location is abstract')
 
650
        push_loc = self.get_config().get_user_option('push_location')
 
651
        return push_loc
441
652
 
442
653
    def set_push_location(self, location):
443
654
        """Set a new push location for this branch."""
444
 
        raise NotImplementedError('set_push_location is abstract')
 
655
        raise NotImplementedError(self.set_push_location)
445
656
 
446
657
    def set_parent(self, url):
447
 
        raise NotImplementedError('set_parent is abstract')
 
658
        raise NotImplementedError(self.set_parent)
448
659
 
449
660
    @needs_write_lock
450
661
    def update(self):
468
679
        Zero (the NULL revision) is considered invalid
469
680
        """
470
681
        if revno < 1 or revno > self.revno():
471
 
            raise InvalidRevisionNumber(revno)
 
682
            raise errors.InvalidRevisionNumber(revno)
472
683
 
473
684
    @needs_read_lock
474
 
    def clone(self, *args, **kwargs):
 
685
    def clone(self, to_bzrdir, revision_id=None):
475
686
        """Clone this branch into to_bzrdir preserving all semantic values.
476
687
        
477
688
        revision_id: if not None, the revision history in the new branch will
478
689
                     be truncated to end with revision_id.
479
690
        """
480
 
        # for API compatibility, until 0.8 releases we provide the old api:
481
 
        # def clone(self, to_location, revision=None, basis_branch=None, to_branch_format=None):
482
 
        # after 0.8 releases, the *args and **kwargs should be changed:
483
 
        # def clone(self, to_bzrdir, revision_id=None):
484
 
        if (kwargs.get('to_location', None) or
485
 
            kwargs.get('revision', None) or
486
 
            kwargs.get('basis_branch', None) or
487
 
            (len(args) and isinstance(args[0], basestring))):
488
 
            # backwards compatibility api:
489
 
            warn("Branch.clone() has been deprecated for BzrDir.clone() from"
490
 
                 " bzrlib 0.8.", DeprecationWarning, stacklevel=3)
491
 
            # get basis_branch
492
 
            if len(args) > 2:
493
 
                basis_branch = args[2]
494
 
            else:
495
 
                basis_branch = kwargs.get('basis_branch', None)
496
 
            if basis_branch:
497
 
                basis = basis_branch.bzrdir
498
 
            else:
499
 
                basis = None
500
 
            # get revision
501
 
            if len(args) > 1:
502
 
                revision_id = args[1]
503
 
            else:
504
 
                revision_id = kwargs.get('revision', None)
505
 
            # get location
506
 
            if len(args):
507
 
                url = args[0]
508
 
            else:
509
 
                # no default to raise if not provided.
510
 
                url = kwargs.get('to_location')
511
 
            return self.bzrdir.clone(url,
512
 
                                     revision_id=revision_id,
513
 
                                     basis=basis).open_branch()
514
 
        # new cleaner api.
515
 
        # generate args by hand 
516
 
        if len(args) > 1:
517
 
            revision_id = args[1]
518
 
        else:
519
 
            revision_id = kwargs.get('revision_id', None)
520
 
        if len(args):
521
 
            to_bzrdir = args[0]
522
 
        else:
523
 
            # no default to raise if not provided.
524
 
            to_bzrdir = kwargs.get('to_bzrdir')
525
 
        result = self._format.initialize(to_bzrdir)
 
691
        result = to_bzrdir.create_branch()
526
692
        self.copy_content_into(result, revision_id=revision_id)
527
693
        return  result
528
694
 
529
695
    @needs_read_lock
530
696
    def sprout(self, to_bzrdir, revision_id=None):
531
697
        """Create a new line of development from the branch, into to_bzrdir.
532
 
        
 
698
 
 
699
        to_bzrdir controls the branch format.
 
700
 
533
701
        revision_id: if not None, the revision history in the new branch will
534
702
                     be truncated to end with revision_id.
535
703
        """
536
 
        result = self._format.initialize(to_bzrdir)
 
704
        result = to_bzrdir.create_branch()
537
705
        self.copy_content_into(result, revision_id=revision_id)
538
706
        result.set_parent(self.bzrdir.root_transport.base)
539
707
        return result
540
708
 
 
709
    def _synchronize_history(self, destination, revision_id):
 
710
        """Synchronize last revision and revision history between branches.
 
711
 
 
712
        This version is most efficient when the destination is also a
 
713
        BzrBranch6, but works for BzrBranch5, as long as the destination's
 
714
        repository contains all the lefthand ancestors of the intended
 
715
        last_revision.  If not, set_last_revision_info will fail.
 
716
 
 
717
        :param destination: The branch to copy the history into
 
718
        :param revision_id: The revision-id to truncate history at.  May
 
719
          be None to copy complete history.
 
720
        """
 
721
        source_revno, source_revision_id = self.last_revision_info()
 
722
        if revision_id is None:
 
723
            revno, revision_id = source_revno, source_revision_id
 
724
        elif source_revision_id == revision_id:
 
725
            # we know the revno without needing to walk all of history
 
726
            revno = source_revno
 
727
        else:
 
728
            # To figure out the revno for a random revision, we need to build
 
729
            # the revision history, and count its length.
 
730
            # We don't care about the order, just how long it is.
 
731
            # Alternatively, we could start at the current location, and count
 
732
            # backwards. But there is no guarantee that we will find it since
 
733
            # it may be a merged revision.
 
734
            revno = len(list(self.repository.iter_reverse_revision_history(
 
735
                                                                revision_id)))
 
736
        destination.set_last_revision_info(revno, revision_id)
 
737
    
541
738
    @needs_read_lock
542
739
    def copy_content_into(self, destination, revision_id=None):
543
740
        """Copy the content of self into destination.
545
742
        revision_id: if not None, the revision history in the new branch will
546
743
                     be truncated to end with revision_id.
547
744
        """
548
 
        new_history = self.revision_history()
549
 
        if revision_id is not None:
550
 
            try:
551
 
                new_history = new_history[:new_history.index(revision_id) + 1]
552
 
            except ValueError:
553
 
                rev = self.repository.get_revision(revision_id)
554
 
                new_history = rev.get_history(self.repository)[1:]
555
 
        destination.set_revision_history(new_history)
556
 
        parent = self.get_parent()
557
 
        if parent:
558
 
            destination.set_parent(parent)
 
745
        self._synchronize_history(destination, revision_id)
 
746
        try:
 
747
            parent = self.get_parent()
 
748
        except errors.InaccessibleParent, e:
 
749
            mutter('parent was not accessible to copy: %s', e)
 
750
        else:
 
751
            if parent:
 
752
                destination.set_parent(parent)
 
753
        self.tags.merge_to(destination.tags)
559
754
 
560
755
    @needs_read_lock
561
756
    def check(self):
564
759
        In particular this checks that revisions given in the revision-history
565
760
        do actually match up in the revision graph, and that they're all 
566
761
        present in the repository.
 
762
        
 
763
        Callers will typically also want to check the repository.
567
764
 
568
765
        :return: A BranchCheckResult.
569
766
        """
570
767
        mainline_parent_id = None
571
 
        for revision_id in self.revision_history():
 
768
        last_revno, last_revision_id = self.last_revision_info()
 
769
        real_rev_history = list(self.repository.iter_reverse_revision_history(
 
770
                                last_revision_id))
 
771
        real_rev_history.reverse()
 
772
        if len(real_rev_history) != last_revno:
 
773
            raise errors.BzrCheckError('revno does not match len(mainline)'
 
774
                ' %s != %s' % (last_revno, len(real_rev_history)))
 
775
        # TODO: We should probably also check that real_rev_history actually
 
776
        #       matches self.revision_history()
 
777
        for revision_id in real_rev_history:
572
778
            try:
573
779
                revision = self.repository.get_revision(revision_id)
574
780
            except errors.NoSuchRevision, e:
575
 
                raise BzrCheckError("mainline revision {%s} not in repository"
576
 
                        % revision_id)
 
781
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
 
782
                            % revision_id)
577
783
            # In general the first entry on the revision history has no parents.
578
784
            # But it's not illegal for it to have parents listed; this can happen
579
785
            # in imports from Arch when the parents weren't reachable.
580
786
            if mainline_parent_id is not None:
581
787
                if mainline_parent_id not in revision.parent_ids:
582
 
                    raise BzrCheckError("previous revision {%s} not listed among "
 
788
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
583
789
                                        "parents of {%s}"
584
790
                                        % (mainline_parent_id, revision_id))
585
791
            mainline_parent_id = revision_id
586
792
        return BranchCheckResult(self)
587
793
 
 
794
    def _get_checkout_format(self):
 
795
        """Return the most suitable metadir for a checkout of this branch.
 
796
        Weaves are used if this branch's repository uses weaves.
 
797
        """
 
798
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
 
799
            from bzrlib.repofmt import weaverepo
 
800
            format = bzrdir.BzrDirMetaFormat1()
 
801
            format.repository_format = weaverepo.RepositoryFormat7()
 
802
        else:
 
803
            format = self.repository.bzrdir.checkout_metadir()
 
804
            format.set_branch_format(self._format)
 
805
        return format
 
806
 
 
807
    def create_checkout(self, to_location, revision_id=None,
 
808
                        lightweight=False, accelerator_tree=None,
 
809
                        hardlink=False):
 
810
        """Create a checkout of a branch.
 
811
        
 
812
        :param to_location: The url to produce the checkout at
 
813
        :param revision_id: The revision to check out
 
814
        :param lightweight: If True, produce a lightweight checkout, otherwise,
 
815
        produce a bound branch (heavyweight checkout)
 
816
        :param accelerator_tree: A tree which can be used for retrieving file
 
817
            contents more quickly than the revision tree, i.e. a workingtree.
 
818
            The revision tree will be used for cases where accelerator_tree's
 
819
            content is different.
 
820
        :param hardlink: If true, hard-link files from accelerator_tree,
 
821
            where possible.
 
822
        :return: The tree of the created checkout
 
823
        """
 
824
        t = transport.get_transport(to_location)
 
825
        t.ensure_base()
 
826
        if lightweight:
 
827
            format = self._get_checkout_format()
 
828
            checkout = format.initialize_on_transport(t)
 
829
            from_branch = BranchReferenceFormat().initialize(checkout, self)
 
830
        else:
 
831
            format = self._get_checkout_format()
 
832
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
 
833
                to_location, force_new_tree=False, format=format)
 
834
            checkout = checkout_branch.bzrdir
 
835
            checkout_branch.bind(self)
 
836
            # pull up to the specified revision_id to set the initial 
 
837
            # branch tip correctly, and seed it with history.
 
838
            checkout_branch.pull(self, stop_revision=revision_id)
 
839
            from_branch=None
 
840
        tree = checkout.create_workingtree(revision_id,
 
841
                                           from_branch=from_branch,
 
842
                                           accelerator_tree=accelerator_tree,
 
843
                                           hardlink=hardlink)
 
844
        basis_tree = tree.basis_tree()
 
845
        basis_tree.lock_read()
 
846
        try:
 
847
            for path, file_id in basis_tree.iter_references():
 
848
                reference_parent = self.reference_parent(file_id, path)
 
849
                reference_parent.create_checkout(tree.abspath(path),
 
850
                    basis_tree.get_reference_revision(file_id, path),
 
851
                    lightweight)
 
852
        finally:
 
853
            basis_tree.unlock()
 
854
        return tree
 
855
 
 
856
    @needs_write_lock
 
857
    def reconcile(self, thorough=True):
 
858
        """Make sure the data stored in this branch is consistent."""
 
859
        from bzrlib.reconcile import BranchReconciler
 
860
        reconciler = BranchReconciler(self, thorough=thorough)
 
861
        reconciler.reconcile()
 
862
        return reconciler
 
863
 
 
864
    def reference_parent(self, file_id, path):
 
865
        """Return the parent branch for a tree-reference file_id
 
866
        :param file_id: The file_id of the tree reference
 
867
        :param path: The path of the file_id in the tree
 
868
        :return: A branch associated with the file_id
 
869
        """
 
870
        # FIXME should provide multiple branches, based on config
 
871
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
 
872
 
 
873
    def supports_tags(self):
 
874
        return self._format.supports_tags()
 
875
 
 
876
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
 
877
                                         other_branch):
 
878
        """Ensure that revision_b is a descendant of revision_a.
 
879
 
 
880
        This is a helper function for update_revisions.
 
881
        
 
882
        :raises: DivergedBranches if revision_b has diverged from revision_a.
 
883
        :returns: True if revision_b is a descendant of revision_a.
 
884
        """
 
885
        relation = self._revision_relations(revision_a, revision_b, graph)
 
886
        if relation == 'b_descends_from_a':
 
887
            return True
 
888
        elif relation == 'diverged':
 
889
            raise errors.DivergedBranches(self, other_branch)
 
890
        elif relation == 'a_descends_from_b':
 
891
            return False
 
892
        else:
 
893
            raise AssertionError("invalid relation: %r" % (relation,))
 
894
 
 
895
    def _revision_relations(self, revision_a, revision_b, graph):
 
896
        """Determine the relationship between two revisions.
 
897
        
 
898
        :returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
 
899
        """
 
900
        heads = graph.heads([revision_a, revision_b])
 
901
        if heads == set([revision_b]):
 
902
            return 'b_descends_from_a'
 
903
        elif heads == set([revision_a, revision_b]):
 
904
            # These branches have diverged
 
905
            return 'diverged'
 
906
        elif heads == set([revision_a]):
 
907
            return 'a_descends_from_b'
 
908
        else:
 
909
            raise AssertionError("invalid heads: %r" % (heads,))
 
910
 
588
911
 
589
912
class BranchFormat(object):
590
913
    """An encapsulation of the initialization and open routines for a format.
610
933
    _formats = {}
611
934
    """The known formats."""
612
935
 
 
936
    def __eq__(self, other):
 
937
        return self.__class__ is other.__class__
 
938
 
 
939
    def __ne__(self, other):
 
940
        return not (self == other)
 
941
 
613
942
    @classmethod
614
943
    def find_format(klass, a_bzrdir):
615
944
        """Return the format for the branch object in a_bzrdir."""
617
946
            transport = a_bzrdir.get_branch_transport(None)
618
947
            format_string = transport.get("format").read()
619
948
            return klass._formats[format_string]
620
 
        except NoSuchFile:
621
 
            raise NotBranchError(path=transport.base)
 
949
        except errors.NoSuchFile:
 
950
            raise errors.NotBranchError(path=transport.base)
622
951
        except KeyError:
623
 
            raise errors.UnknownFormatError(format_string)
 
952
            raise errors.UnknownFormatError(format=format_string, kind='branch')
624
953
 
625
954
    @classmethod
626
955
    def get_default_format(klass):
627
956
        """Return the current default format."""
628
957
        return klass._default_format
629
958
 
 
959
    def get_reference(self, a_bzrdir):
 
960
        """Get the target reference of the branch in a_bzrdir.
 
961
 
 
962
        format probing must have been completed before calling
 
963
        this method - it is assumed that the format of the branch
 
964
        in a_bzrdir is correct.
 
965
 
 
966
        :param a_bzrdir: The bzrdir to get the branch data from.
 
967
        :return: None if the branch is not a reference branch.
 
968
        """
 
969
        return None
 
970
 
 
971
    @classmethod
 
972
    def set_reference(self, a_bzrdir, to_branch):
 
973
        """Set the target reference of the branch in a_bzrdir.
 
974
 
 
975
        format probing must have been completed before calling
 
976
        this method - it is assumed that the format of the branch
 
977
        in a_bzrdir is correct.
 
978
 
 
979
        :param a_bzrdir: The bzrdir to set the branch reference for.
 
980
        :param to_branch: branch that the checkout is to reference
 
981
        """
 
982
        raise NotImplementedError(self.set_reference)
 
983
 
630
984
    def get_format_string(self):
631
985
        """Return the ASCII format string that identifies this format."""
632
986
        raise NotImplementedError(self.get_format_string)
633
987
 
634
988
    def get_format_description(self):
635
989
        """Return the short format description for this format."""
636
 
        raise NotImplementedError(self.get_format_string)
 
990
        raise NotImplementedError(self.get_format_description)
 
991
 
 
992
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
 
993
                           set_format=True):
 
994
        """Initialize a branch in a bzrdir, with specified files
 
995
 
 
996
        :param a_bzrdir: The bzrdir to initialize the branch in
 
997
        :param utf8_files: The files to create as a list of
 
998
            (filename, content) tuples
 
999
        :param set_format: If True, set the format with
 
1000
            self.get_format_string.  (BzrBranch4 has its format set
 
1001
            elsewhere)
 
1002
        :return: a branch in this format
 
1003
        """
 
1004
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
1005
        branch_transport = a_bzrdir.get_branch_transport(self)
 
1006
        lock_map = {
 
1007
            'metadir': ('lock', lockdir.LockDir),
 
1008
            'branch4': ('branch-lock', lockable_files.TransportLock),
 
1009
        }
 
1010
        lock_name, lock_class = lock_map[lock_type]
 
1011
        control_files = lockable_files.LockableFiles(branch_transport,
 
1012
            lock_name, lock_class)
 
1013
        control_files.create_lock()
 
1014
        control_files.lock_write()
 
1015
        if set_format:
 
1016
            utf8_files += [('format', self.get_format_string())]
 
1017
        try:
 
1018
            for (filename, content) in utf8_files:
 
1019
                branch_transport.put_bytes(
 
1020
                    filename, content,
 
1021
                    mode=a_bzrdir._get_file_mode())
 
1022
        finally:
 
1023
            control_files.unlock()
 
1024
        return self.open(a_bzrdir, _found=True)
637
1025
 
638
1026
    def initialize(self, a_bzrdir):
639
1027
        """Create a branch of this format in a_bzrdir."""
664
1052
    def set_default_format(klass, format):
665
1053
        klass._default_format = format
666
1054
 
 
1055
    def supports_stacking(self):
 
1056
        """True if this format records a stacked-on branch."""
 
1057
        return False
 
1058
 
667
1059
    @classmethod
668
1060
    def unregister_format(klass, format):
669
 
        assert klass._formats[format.get_format_string()] is format
670
1061
        del klass._formats[format.get_format_string()]
671
1062
 
672
1063
    def __str__(self):
673
1064
        return self.get_format_string().rstrip()
674
1065
 
 
1066
    def supports_tags(self):
 
1067
        """True if this format supports tags stored in the branch"""
 
1068
        return False  # by default
 
1069
 
 
1070
 
 
1071
class BranchHooks(Hooks):
 
1072
    """A dictionary mapping hook name to a list of callables for branch hooks.
 
1073
    
 
1074
    e.g. ['set_rh'] Is the list of items to be called when the
 
1075
    set_revision_history function is invoked.
 
1076
    """
 
1077
 
 
1078
    def __init__(self):
 
1079
        """Create the default hooks.
 
1080
 
 
1081
        These are all empty initially, because by default nothing should get
 
1082
        notified.
 
1083
        """
 
1084
        Hooks.__init__(self)
 
1085
        # Introduced in 0.15:
 
1086
        # invoked whenever the revision history has been set
 
1087
        # with set_revision_history. The api signature is
 
1088
        # (branch, revision_history), and the branch will
 
1089
        # be write-locked.
 
1090
        self['set_rh'] = []
 
1091
        # Invoked after a branch is opened. The api signature is (branch).
 
1092
        self['open'] = []
 
1093
        # invoked after a push operation completes.
 
1094
        # the api signature is
 
1095
        # (push_result)
 
1096
        # containing the members
 
1097
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
1098
        # where local is the local target branch or None, master is the target 
 
1099
        # master branch, and the rest should be self explanatory. The source
 
1100
        # is read locked and the target branches write locked. Source will
 
1101
        # be the local low-latency branch.
 
1102
        self['post_push'] = []
 
1103
        # invoked after a pull operation completes.
 
1104
        # the api signature is
 
1105
        # (pull_result)
 
1106
        # containing the members
 
1107
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
1108
        # where local is the local branch or None, master is the target 
 
1109
        # master branch, and the rest should be self explanatory. The source
 
1110
        # is read locked and the target branches write locked. The local
 
1111
        # branch is the low-latency branch.
 
1112
        self['post_pull'] = []
 
1113
        # invoked before a commit operation takes place.
 
1114
        # the api signature is
 
1115
        # (local, master, old_revno, old_revid, future_revno, future_revid,
 
1116
        #  tree_delta, future_tree).
 
1117
        # old_revid is NULL_REVISION for the first commit to a branch
 
1118
        # tree_delta is a TreeDelta object describing changes from the basis
 
1119
        # revision, hooks MUST NOT modify this delta
 
1120
        # future_tree is an in-memory tree obtained from
 
1121
        # CommitBuilder.revision_tree() and hooks MUST NOT modify this tree
 
1122
        self['pre_commit'] = []
 
1123
        # invoked after a commit operation completes.
 
1124
        # the api signature is 
 
1125
        # (local, master, old_revno, old_revid, new_revno, new_revid)
 
1126
        # old_revid is NULL_REVISION for the first commit to a branch.
 
1127
        self['post_commit'] = []
 
1128
        # invoked after a uncommit operation completes.
 
1129
        # the api signature is
 
1130
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
 
1131
        # local is the local branch or None, master is the target branch,
 
1132
        # and an empty branch recieves new_revno of 0, new_revid of None.
 
1133
        self['post_uncommit'] = []
 
1134
        # Introduced in 1.6
 
1135
        # Invoked before the tip of a branch changes.
 
1136
        # the api signature is
 
1137
        # (params) where params is a ChangeBranchTipParams with the members
 
1138
        # (branch, old_revno, new_revno, old_revid, new_revid)
 
1139
        self['pre_change_branch_tip'] = []
 
1140
        # Introduced in 1.4
 
1141
        # Invoked after the tip of a branch changes.
 
1142
        # the api signature is
 
1143
        # (params) where params is a ChangeBranchTipParams with the members
 
1144
        # (branch, old_revno, new_revno, old_revid, new_revid)
 
1145
        self['post_change_branch_tip'] = []
 
1146
        # Introduced in 1.9
 
1147
        # Invoked when a stacked branch activates its fallback locations and
 
1148
        # allows the transformation of the url of said location.
 
1149
        # the api signature is
 
1150
        # (branch, url) where branch is the branch having its fallback
 
1151
        # location activated and url is the url for the fallback location.
 
1152
        # The hook should return a url.
 
1153
        self['transform_fallback_location'] = []
 
1154
 
 
1155
 
 
1156
# install the default hooks into the Branch class.
 
1157
Branch.hooks = BranchHooks()
 
1158
 
 
1159
 
 
1160
class ChangeBranchTipParams(object):
 
1161
    """Object holding parameters passed to *_change_branch_tip hooks.
 
1162
 
 
1163
    There are 5 fields that hooks may wish to access:
 
1164
 
 
1165
    :ivar branch: the branch being changed
 
1166
    :ivar old_revno: revision number before the change
 
1167
    :ivar new_revno: revision number after the change
 
1168
    :ivar old_revid: revision id before the change
 
1169
    :ivar new_revid: revision id after the change
 
1170
 
 
1171
    The revid fields are strings. The revno fields are integers.
 
1172
    """
 
1173
 
 
1174
    def __init__(self, branch, old_revno, new_revno, old_revid, new_revid):
 
1175
        """Create a group of ChangeBranchTip parameters.
 
1176
 
 
1177
        :param branch: The branch being changed.
 
1178
        :param old_revno: Revision number before the change.
 
1179
        :param new_revno: Revision number after the change.
 
1180
        :param old_revid: Tip revision id before the change.
 
1181
        :param new_revid: Tip revision id after the change.
 
1182
        """
 
1183
        self.branch = branch
 
1184
        self.old_revno = old_revno
 
1185
        self.new_revno = new_revno
 
1186
        self.old_revid = old_revid
 
1187
        self.new_revid = new_revid
 
1188
 
 
1189
    def __eq__(self, other):
 
1190
        return self.__dict__ == other.__dict__
 
1191
    
 
1192
    def __repr__(self):
 
1193
        return "<%s of %s from (%s, %s) to (%s, %s)>" % (
 
1194
            self.__class__.__name__, self.branch, 
 
1195
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
 
1196
 
675
1197
 
676
1198
class BzrBranchFormat4(BranchFormat):
677
1199
    """Bzr branch format 4.
687
1209
 
688
1210
    def initialize(self, a_bzrdir):
689
1211
        """Create a branch of this format in a_bzrdir."""
690
 
        mutter('creating branch in %s', a_bzrdir.transport.base)
691
 
        branch_transport = a_bzrdir.get_branch_transport(self)
692
1212
        utf8_files = [('revision-history', ''),
693
1213
                      ('branch-name', ''),
694
1214
                      ]
695
 
        control_files = LockableFiles(branch_transport, 'branch-lock',
696
 
                                      TransportLock)
697
 
        control_files.create_lock()
698
 
        control_files.lock_write()
699
 
        try:
700
 
            for file, content in utf8_files:
701
 
                control_files.put_utf8(file, content)
702
 
        finally:
703
 
            control_files.unlock()
704
 
        return self.open(a_bzrdir, _found=True)
 
1215
        return self._initialize_helper(a_bzrdir, utf8_files,
 
1216
                                       lock_type='branch4', set_format=False)
705
1217
 
706
1218
    def __init__(self):
707
1219
        super(BzrBranchFormat4, self).__init__()
725
1237
        return "Bazaar-NG branch format 4"
726
1238
 
727
1239
 
728
 
class BzrBranchFormat5(BranchFormat):
 
1240
class BranchFormatMetadir(BranchFormat):
 
1241
    """Common logic for meta-dir based branch formats."""
 
1242
 
 
1243
    def _branch_class(self):
 
1244
        """What class to instantiate on open calls."""
 
1245
        raise NotImplementedError(self._branch_class)
 
1246
 
 
1247
    def open(self, a_bzrdir, _found=False):
 
1248
        """Return the branch object for a_bzrdir.
 
1249
 
 
1250
        _found is a private parameter, do not use it. It is used to indicate
 
1251
               if format probing has already be done.
 
1252
        """
 
1253
        if not _found:
 
1254
            format = BranchFormat.find_format(a_bzrdir)
 
1255
            if format.__class__ != self.__class__:
 
1256
                raise AssertionError("wrong format %r found for %r" %
 
1257
                    (format, self))
 
1258
        try:
 
1259
            transport = a_bzrdir.get_branch_transport(None)
 
1260
            control_files = lockable_files.LockableFiles(transport, 'lock',
 
1261
                                                         lockdir.LockDir)
 
1262
            return self._branch_class()(_format=self,
 
1263
                              _control_files=control_files,
 
1264
                              a_bzrdir=a_bzrdir,
 
1265
                              _repository=a_bzrdir.find_repository())
 
1266
        except errors.NoSuchFile:
 
1267
            raise errors.NotBranchError(path=transport.base)
 
1268
 
 
1269
    def __init__(self):
 
1270
        super(BranchFormatMetadir, self).__init__()
 
1271
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1272
        self._matchingbzrdir.set_branch_format(self)
 
1273
 
 
1274
    def supports_tags(self):
 
1275
        return True
 
1276
 
 
1277
 
 
1278
class BzrBranchFormat5(BranchFormatMetadir):
729
1279
    """Bzr branch format 5.
730
1280
 
731
1281
    This format has:
738
1288
    This format is new in bzr 0.8.
739
1289
    """
740
1290
 
 
1291
    def _branch_class(self):
 
1292
        return BzrBranch5
 
1293
 
741
1294
    def get_format_string(self):
742
1295
        """See BranchFormat.get_format_string()."""
743
1296
        return "Bazaar-NG branch format 5\n"
748
1301
        
749
1302
    def initialize(self, a_bzrdir):
750
1303
        """Create a branch of this format in a_bzrdir."""
751
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
752
 
        branch_transport = a_bzrdir.get_branch_transport(self)
753
1304
        utf8_files = [('revision-history', ''),
754
1305
                      ('branch-name', ''),
755
1306
                      ]
756
 
        control_files = LockableFiles(branch_transport, 'lock', LockDir)
757
 
        control_files.create_lock()
758
 
        control_files.lock_write()
759
 
        control_files.put_utf8('format', self.get_format_string())
760
 
        try:
761
 
            for file, content in utf8_files:
762
 
                control_files.put_utf8(file, content)
763
 
        finally:
764
 
            control_files.unlock()
765
 
        return self.open(a_bzrdir, _found=True, )
 
1307
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1308
 
 
1309
    def supports_tags(self):
 
1310
        return False
 
1311
 
 
1312
 
 
1313
class BzrBranchFormat6(BranchFormatMetadir):
 
1314
    """Branch format with last-revision and tags.
 
1315
 
 
1316
    Unlike previous formats, this has no explicit revision history. Instead,
 
1317
    this just stores the last-revision, and the left-hand history leading
 
1318
    up to there is the history.
 
1319
 
 
1320
    This format was introduced in bzr 0.15
 
1321
    and became the default in 0.91.
 
1322
    """
 
1323
 
 
1324
    def _branch_class(self):
 
1325
        return BzrBranch6
 
1326
 
 
1327
    def get_format_string(self):
 
1328
        """See BranchFormat.get_format_string()."""
 
1329
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
 
1330
 
 
1331
    def get_format_description(self):
 
1332
        """See BranchFormat.get_format_description()."""
 
1333
        return "Branch format 6"
 
1334
 
 
1335
    def initialize(self, a_bzrdir):
 
1336
        """Create a branch of this format in a_bzrdir."""
 
1337
        utf8_files = [('last-revision', '0 null:\n'),
 
1338
                      ('branch.conf', ''),
 
1339
                      ('tags', ''),
 
1340
                      ]
 
1341
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1342
 
 
1343
 
 
1344
class BzrBranchFormat7(BranchFormatMetadir):
 
1345
    """Branch format with last-revision, tags, and a stacked location pointer.
 
1346
 
 
1347
    The stacked location pointer is passed down to the repository and requires
 
1348
    a repository format with supports_external_lookups = True.
 
1349
 
 
1350
    This format was introduced in bzr 1.6.
 
1351
    """
 
1352
 
 
1353
    def _branch_class(self):
 
1354
        return BzrBranch7
 
1355
 
 
1356
    def get_format_string(self):
 
1357
        """See BranchFormat.get_format_string()."""
 
1358
        return "Bazaar Branch Format 7 (needs bzr 1.6)\n"
 
1359
 
 
1360
    def get_format_description(self):
 
1361
        """See BranchFormat.get_format_description()."""
 
1362
        return "Branch format 7"
 
1363
 
 
1364
    def initialize(self, a_bzrdir):
 
1365
        """Create a branch of this format in a_bzrdir."""
 
1366
        utf8_files = [('last-revision', '0 null:\n'),
 
1367
                      ('branch.conf', ''),
 
1368
                      ('tags', ''),
 
1369
                      ]
 
1370
        return self._initialize_helper(a_bzrdir, utf8_files)
766
1371
 
767
1372
    def __init__(self):
768
 
        super(BzrBranchFormat5, self).__init__()
769
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
770
 
 
771
 
    def open(self, a_bzrdir, _found=False):
772
 
        """Return the branch object for a_bzrdir
773
 
 
774
 
        _found is a private parameter, do not use it. It is used to indicate
775
 
               if format probing has already be done.
776
 
        """
777
 
        if not _found:
778
 
            format = BranchFormat.find_format(a_bzrdir)
779
 
            assert format.__class__ == self.__class__
780
 
        transport = a_bzrdir.get_branch_transport(None)
781
 
        control_files = LockableFiles(transport, 'lock', LockDir)
782
 
        return BzrBranch5(_format=self,
783
 
                          _control_files=control_files,
784
 
                          a_bzrdir=a_bzrdir,
785
 
                          _repository=a_bzrdir.find_repository())
786
 
 
787
 
    def __str__(self):
788
 
        return "Bazaar-NG Metadir branch format 5"
 
1373
        super(BzrBranchFormat7, self).__init__()
 
1374
        self._matchingbzrdir.repository_format = \
 
1375
            RepositoryFormatKnitPack5RichRoot()
 
1376
 
 
1377
    def supports_stacking(self):
 
1378
        return True
789
1379
 
790
1380
 
791
1381
class BranchReferenceFormat(BranchFormat):
806
1396
    def get_format_description(self):
807
1397
        """See BranchFormat.get_format_description()."""
808
1398
        return "Checkout reference format 1"
809
 
        
 
1399
 
 
1400
    def get_reference(self, a_bzrdir):
 
1401
        """See BranchFormat.get_reference()."""
 
1402
        transport = a_bzrdir.get_branch_transport(None)
 
1403
        return transport.get('location').read()
 
1404
 
 
1405
    def set_reference(self, a_bzrdir, to_branch):
 
1406
        """See BranchFormat.set_reference()."""
 
1407
        transport = a_bzrdir.get_branch_transport(None)
 
1408
        location = transport.put_bytes('location', to_branch.base)
 
1409
 
810
1410
    def initialize(self, a_bzrdir, target_branch=None):
811
1411
        """Create a branch of this format in a_bzrdir."""
812
1412
        if target_branch is None:
815
1415
            raise errors.UninitializableFormat(self)
816
1416
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
817
1417
        branch_transport = a_bzrdir.get_branch_transport(self)
818
 
        # FIXME rbc 20060209 one j-a-ms encoding branch lands this str() cast is not needed.
819
 
        branch_transport.put('location', StringIO(str(target_branch.bzrdir.root_transport.base)))
820
 
        branch_transport.put('format', StringIO(self.get_format_string()))
821
 
        return self.open(a_bzrdir, _found=True)
 
1418
        branch_transport.put_bytes('location',
 
1419
            target_branch.bzrdir.root_transport.base)
 
1420
        branch_transport.put_bytes('format', self.get_format_string())
 
1421
        return self.open(
 
1422
            a_bzrdir, _found=True,
 
1423
            possible_transports=[target_branch.bzrdir.root_transport])
822
1424
 
823
1425
    def __init__(self):
824
1426
        super(BranchReferenceFormat, self).__init__()
825
1427
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1428
        self._matchingbzrdir.set_branch_format(self)
826
1429
 
827
1430
    def _make_reference_clone_function(format, a_branch):
828
1431
        """Create a clone() routine for a branch dynamically."""
834
1437
            # emit some sort of warning/error to the caller ?!
835
1438
        return clone
836
1439
 
837
 
    def open(self, a_bzrdir, _found=False):
 
1440
    def open(self, a_bzrdir, _found=False, location=None,
 
1441
             possible_transports=None):
838
1442
        """Return the branch that the branch reference in a_bzrdir points at.
839
1443
 
840
1444
        _found is a private parameter, do not use it. It is used to indicate
842
1446
        """
843
1447
        if not _found:
844
1448
            format = BranchFormat.find_format(a_bzrdir)
845
 
            assert format.__class__ == self.__class__
846
 
        transport = a_bzrdir.get_branch_transport(None)
847
 
        real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
 
1449
            if format.__class__ != self.__class__:
 
1450
                raise AssertionError("wrong format %r found for %r" %
 
1451
                    (format, self))
 
1452
        if location is None:
 
1453
            location = self.get_reference(a_bzrdir)
 
1454
        real_bzrdir = bzrdir.BzrDir.open(
 
1455
            location, possible_transports=possible_transports)
848
1456
        result = real_bzrdir.open_branch()
849
1457
        # this changes the behaviour of result.clone to create a new reference
850
1458
        # rather than a copy of the content of the branch.
860
1468
 
861
1469
# formats which have no format string are not discoverable
862
1470
# and not independently creatable, so are not registered.
863
 
__default_format = BzrBranchFormat5()
864
 
BranchFormat.register_format(__default_format)
 
1471
__format5 = BzrBranchFormat5()
 
1472
__format6 = BzrBranchFormat6()
 
1473
__format7 = BzrBranchFormat7()
 
1474
BranchFormat.register_format(__format5)
865
1475
BranchFormat.register_format(BranchReferenceFormat())
866
 
BranchFormat.set_default_format(__default_format)
 
1476
BranchFormat.register_format(__format6)
 
1477
BranchFormat.register_format(__format7)
 
1478
BranchFormat.set_default_format(__format6)
867
1479
_legacy_formats = [BzrBranchFormat4(),
868
1480
                   ]
869
1481
 
873
1485
    Note that it's "local" in the context of the filesystem; it doesn't
874
1486
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
875
1487
    it's writable, and can be accessed via the normal filesystem API.
 
1488
 
 
1489
    :ivar _transport: Transport for file operations on this branch's 
 
1490
        control files, typically pointing to the .bzr/branch directory.
 
1491
    :ivar repository: Repository for this branch.
 
1492
    :ivar base: The url of the base directory for this branch; the one 
 
1493
        containing the .bzr directory.
876
1494
    """
877
1495
    
878
 
    def __init__(self, transport=DEPRECATED_PARAMETER, init=DEPRECATED_PARAMETER,
879
 
                 relax_version_check=DEPRECATED_PARAMETER, _format=None,
 
1496
    def __init__(self, _format=None,
880
1497
                 _control_files=None, a_bzrdir=None, _repository=None):
881
 
        """Create new branch object at a particular location.
882
 
 
883
 
        transport -- A Transport object, defining how to access files.
884
 
        
885
 
        init -- If True, create new control files in a previously
886
 
             unversioned directory.  If False, the branch must already
887
 
             be versioned.
888
 
 
889
 
        relax_version_check -- If true, the usual check for the branch
890
 
            version is not applied.  This is intended only for
891
 
            upgrade/recovery type use; it's not guaranteed that
892
 
            all operations will work on old format branches.
893
 
        """
 
1498
        """Create new branch object at a particular location."""
894
1499
        if a_bzrdir is None:
895
 
            self.bzrdir = bzrdir.BzrDir.open(transport.base)
 
1500
            raise ValueError('a_bzrdir must be supplied')
896
1501
        else:
897
1502
            self.bzrdir = a_bzrdir
898
 
        self._transport = self.bzrdir.transport.clone('..')
899
 
        self._base = self._transport.base
 
1503
        self._base = self.bzrdir.transport.clone('..').base
 
1504
        # XXX: We should be able to just do
 
1505
        #   self.base = self.bzrdir.root_transport.base
 
1506
        # but this does not quite work yet -- mbp 20080522
900
1507
        self._format = _format
901
1508
        if _control_files is None:
902
 
            raise BzrBadParameterMissing('_control_files')
 
1509
            raise ValueError('BzrBranch _control_files is None')
903
1510
        self.control_files = _control_files
904
 
        if deprecated_passed(init):
905
 
            warn("BzrBranch.__init__(..., init=XXX): The init parameter is "
906
 
                 "deprecated as of bzr 0.8. Please use Branch.create().",
907
 
                 DeprecationWarning,
908
 
                 stacklevel=2)
909
 
            if init:
910
 
                # this is slower than before deprecation, oh well never mind.
911
 
                # -> its deprecated.
912
 
                self._initialize(transport.base)
913
 
        self._check_format(_format)
914
 
        if deprecated_passed(relax_version_check):
915
 
            warn("BzrBranch.__init__(..., relax_version_check=XXX_: The "
916
 
                 "relax_version_check parameter is deprecated as of bzr 0.8. "
917
 
                 "Please use BzrDir.open_downlevel, or a BzrBranchFormat's "
918
 
                 "open() method.",
919
 
                 DeprecationWarning,
920
 
                 stacklevel=2)
921
 
            if (not relax_version_check
922
 
                and not self._format.is_supported()):
923
 
                raise errors.UnsupportedFormatError(
924
 
                        'sorry, branch format %r not supported' % fmt,
925
 
                        ['use a different bzr version',
926
 
                         'or remove the .bzr directory'
927
 
                         ' and "bzr init" again'])
928
 
        if deprecated_passed(transport):
929
 
            warn("BzrBranch.__init__(transport=XXX...): The transport "
930
 
                 "parameter is deprecated as of bzr 0.8. "
931
 
                 "Please use Branch.open, or bzrdir.open_branch().",
932
 
                 DeprecationWarning,
933
 
                 stacklevel=2)
 
1511
        self._transport = _control_files._transport
934
1512
        self.repository = _repository
 
1513
        Branch.__init__(self)
935
1514
 
936
1515
    def __str__(self):
937
1516
        return '%s(%r)' % (self.__class__.__name__, self.base)
938
1517
 
939
1518
    __repr__ = __str__
940
1519
 
941
 
    def __del__(self):
942
 
        # TODO: It might be best to do this somewhere else,
943
 
        # but it is nice for a Branch object to automatically
944
 
        # cache it's information.
945
 
        # Alternatively, we could have the Transport objects cache requests
946
 
        # See the earlier discussion about how major objects (like Branch)
947
 
        # should never expect their __del__ function to run.
948
 
        # XXX: cache_root seems to be unused, 2006-01-13 mbp
949
 
        if hasattr(self, 'cache_root') and self.cache_root is not None:
950
 
            try:
951
 
                rmtree(self.cache_root)
952
 
            except:
953
 
                pass
954
 
            self.cache_root = None
955
 
 
956
1520
    def _get_base(self):
 
1521
        """Returns the directory containing the control directory."""
957
1522
        return self._base
958
1523
 
959
1524
    base = property(_get_base, doc="The URL for the root of this branch.")
960
1525
 
961
 
    def _finish_transaction(self):
962
 
        """Exit the current transaction."""
963
 
        return self.control_files._finish_transaction()
964
 
 
965
 
    def get_transaction(self):
966
 
        """Return the current active transaction.
967
 
 
968
 
        If no transaction is active, this returns a passthrough object
969
 
        for which all data is immediately flushed and no caching happens.
970
 
        """
971
 
        # this is an explicit function so that we can do tricky stuff
972
 
        # when the storage in rev_storage is elsewhere.
973
 
        # we probably need to hook the two 'lock a location' and 
974
 
        # 'have a transaction' together more delicately, so that
975
 
        # we can have two locks (branch and storage) and one transaction
976
 
        # ... and finishing the transaction unlocks both, but unlocking
977
 
        # does not. - RBC 20051121
978
 
        return self.control_files.get_transaction()
979
 
 
980
 
    def _set_transaction(self, transaction):
981
 
        """Set a new active transaction."""
982
 
        return self.control_files._set_transaction(transaction)
983
 
 
984
 
    def abspath(self, name):
985
 
        """See Branch.abspath."""
986
 
        return self.control_files._transport.abspath(name)
987
 
 
988
 
    def _check_format(self, format):
989
 
        """Identify the branch format if needed.
990
 
 
991
 
        The format is stored as a reference to the format object in
992
 
        self._format for code that needs to check it later.
993
 
 
994
 
        The format parameter is either None or the branch format class
995
 
        used to open this branch.
996
 
 
997
 
        FIXME: DELETE THIS METHOD when pre 0.8 support is removed.
998
 
        """
999
 
        if format is None:
1000
 
            format = BzrBranchFormat.find_format(self.bzrdir)
1001
 
        self._format = format
1002
 
        mutter("got branch format %s", self._format)
1003
 
 
1004
 
    @needs_read_lock
1005
 
    def get_root_id(self):
1006
 
        """See Branch.get_root_id."""
1007
 
        tree = self.repository.revision_tree(self.last_revision())
1008
 
        return tree.inventory.root.file_id
1009
 
 
1010
1526
    def is_locked(self):
1011
1527
        return self.control_files.is_locked()
1012
1528
 
1013
 
    def lock_write(self):
1014
 
        # TODO: test for failed two phase locks. This is known broken.
1015
 
        self.control_files.lock_write()
1016
 
        self.repository.lock_write()
 
1529
    def lock_write(self, token=None):
 
1530
        repo_token = self.repository.lock_write()
 
1531
        try:
 
1532
            token = self.control_files.lock_write(token=token)
 
1533
        except:
 
1534
            self.repository.unlock()
 
1535
            raise
 
1536
        return token
1017
1537
 
1018
1538
    def lock_read(self):
1019
 
        # TODO: test for failed two phase locks. This is known broken.
1020
 
        self.control_files.lock_read()
1021
1539
        self.repository.lock_read()
 
1540
        try:
 
1541
            self.control_files.lock_read()
 
1542
        except:
 
1543
            self.repository.unlock()
 
1544
            raise
1022
1545
 
1023
1546
    def unlock(self):
1024
1547
        # TODO: test for failed two phase locks. This is known broken.
1025
1548
        try:
1026
 
            self.repository.unlock()
1027
 
        finally:
1028
1549
            self.control_files.unlock()
 
1550
        finally:
 
1551
            self.repository.unlock()
 
1552
        if not self.control_files.is_locked():
 
1553
            # we just released the lock
 
1554
            self._clear_cached_state()
1029
1555
        
1030
1556
    def peek_lock_mode(self):
1031
1557
        if self.control_files._lock_count == 0:
1041
1567
        """See Branch.print_file."""
1042
1568
        return self.repository.print_file(file, revision_id)
1043
1569
 
1044
 
    @needs_write_lock
1045
 
    def append_revision(self, *revision_ids):
1046
 
        """See Branch.append_revision."""
1047
 
        for revision_id in revision_ids:
1048
 
            mutter("add {%s} to revision-history" % revision_id)
1049
 
        rev_history = self.revision_history()
1050
 
        rev_history.extend(revision_ids)
1051
 
        self.set_revision_history(rev_history)
 
1570
    def _write_revision_history(self, history):
 
1571
        """Factored out of set_revision_history.
 
1572
 
 
1573
        This performs the actual writing to disk.
 
1574
        It is intended to be called by BzrBranch5.set_revision_history."""
 
1575
        self._transport.put_bytes(
 
1576
            'revision-history', '\n'.join(history),
 
1577
            mode=self.bzrdir._get_file_mode())
1052
1578
 
1053
1579
    @needs_write_lock
1054
1580
    def set_revision_history(self, rev_history):
1055
1581
        """See Branch.set_revision_history."""
1056
 
        self.control_files.put_utf8(
1057
 
            'revision-history', '\n'.join(rev_history))
1058
 
        transaction = self.get_transaction()
1059
 
        history = transaction.map.find_revision_history()
1060
 
        if history is not None:
1061
 
            # update the revision history in the identity map.
1062
 
            history[:] = list(rev_history)
1063
 
            # this call is disabled because revision_history is 
1064
 
            # not really an object yet, and the transaction is for objects.
1065
 
            # transaction.register_dirty(history)
 
1582
        if 'evil' in debug.debug_flags:
 
1583
            mutter_callsite(3, "set_revision_history scales with history.")
 
1584
        check_not_reserved_id = _mod_revision.check_not_reserved_id
 
1585
        for rev_id in rev_history:
 
1586
            check_not_reserved_id(rev_id)
 
1587
        if Branch.hooks['post_change_branch_tip']:
 
1588
            # Don't calculate the last_revision_info() if there are no hooks
 
1589
            # that will use it.
 
1590
            old_revno, old_revid = self.last_revision_info()
 
1591
        if len(rev_history) == 0:
 
1592
            revid = _mod_revision.NULL_REVISION
1066
1593
        else:
1067
 
            transaction.map.add_revision_history(rev_history)
1068
 
            # this call is disabled because revision_history is 
1069
 
            # not really an object yet, and the transaction is for objects.
1070
 
            # transaction.register_clean(history)
1071
 
 
1072
 
    def get_revision_delta(self, revno):
1073
 
        """Return the delta for one revision.
1074
 
 
1075
 
        The delta is relative to its mainline predecessor, or the
1076
 
        empty tree for revision 1.
 
1594
            revid = rev_history[-1]
 
1595
        self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
 
1596
        self._write_revision_history(rev_history)
 
1597
        self._clear_cached_state()
 
1598
        self._cache_revision_history(rev_history)
 
1599
        for hook in Branch.hooks['set_rh']:
 
1600
            hook(self, rev_history)
 
1601
        if Branch.hooks['post_change_branch_tip']:
 
1602
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
1603
 
 
1604
    def _synchronize_history(self, destination, revision_id):
 
1605
        """Synchronize last revision and revision history between branches.
 
1606
 
 
1607
        This version is most efficient when the destination is also a
 
1608
        BzrBranch5, but works for BzrBranch6 as long as the revision
 
1609
        history is the true lefthand parent history, and all of the revisions
 
1610
        are in the destination's repository.  If not, set_revision_history
 
1611
        will fail.
 
1612
 
 
1613
        :param destination: The branch to copy the history into
 
1614
        :param revision_id: The revision-id to truncate history at.  May
 
1615
          be None to copy complete history.
1077
1616
        """
1078
 
        assert isinstance(revno, int)
1079
 
        rh = self.revision_history()
1080
 
        if not (1 <= revno <= len(rh)):
1081
 
            raise InvalidRevisionNumber(revno)
1082
 
 
1083
 
        # revno is 1-based; list is 0-based
1084
 
 
1085
 
        new_tree = self.repository.revision_tree(rh[revno-1])
1086
 
        if revno == 1:
1087
 
            old_tree = EmptyTree()
 
1617
        if not isinstance(destination._format, BzrBranchFormat5):
 
1618
            super(BzrBranch, self)._synchronize_history(
 
1619
                destination, revision_id)
 
1620
            return
 
1621
        if revision_id == _mod_revision.NULL_REVISION:
 
1622
            new_history = []
1088
1623
        else:
1089
 
            old_tree = self.repository.revision_tree(rh[revno-2])
1090
 
        return compare_trees(old_tree, new_tree)
1091
 
 
1092
 
    @needs_read_lock
1093
 
    def revision_history(self):
1094
 
        """See Branch.revision_history."""
1095
 
        transaction = self.get_transaction()
1096
 
        history = transaction.map.find_revision_history()
1097
 
        if history is not None:
1098
 
            mutter("cache hit for revision-history in %s", self)
1099
 
            return list(history)
1100
 
        history = [l.rstrip('\r\n') for l in
1101
 
                self.control_files.get_utf8('revision-history').readlines()]
1102
 
        transaction.map.add_revision_history(history)
1103
 
        # this call is disabled because revision_history is 
1104
 
        # not really an object yet, and the transaction is for objects.
1105
 
        # transaction.register_clean(history, precious=True)
1106
 
        return list(history)
1107
 
 
 
1624
            new_history = self.revision_history()
 
1625
        if revision_id is not None and new_history != []:
 
1626
            try:
 
1627
                new_history = new_history[:new_history.index(revision_id) + 1]
 
1628
            except ValueError:
 
1629
                rev = self.repository.get_revision(revision_id)
 
1630
                new_history = rev.get_history(self.repository)[1:]
 
1631
        destination.set_revision_history(new_history)
 
1632
 
 
1633
    def _run_pre_change_branch_tip_hooks(self, new_revno, new_revid):
 
1634
        """Run the pre_change_branch_tip hooks."""
 
1635
        hooks = Branch.hooks['pre_change_branch_tip']
 
1636
        if not hooks:
 
1637
            return
 
1638
        old_revno, old_revid = self.last_revision_info()
 
1639
        params = ChangeBranchTipParams(
 
1640
            self, old_revno, new_revno, old_revid, new_revid)
 
1641
        for hook in hooks:
 
1642
            try:
 
1643
                hook(params)
 
1644
            except errors.TipChangeRejected:
 
1645
                raise
 
1646
            except Exception:
 
1647
                exc_info = sys.exc_info()
 
1648
                hook_name = Branch.hooks.get_hook_name(hook)
 
1649
                raise errors.HookFailed(
 
1650
                    'pre_change_branch_tip', hook_name, exc_info)
 
1651
 
 
1652
    def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
 
1653
        """Run the post_change_branch_tip hooks."""
 
1654
        hooks = Branch.hooks['post_change_branch_tip']
 
1655
        if not hooks:
 
1656
            return
 
1657
        new_revno, new_revid = self.last_revision_info()
 
1658
        params = ChangeBranchTipParams(
 
1659
            self, old_revno, new_revno, old_revid, new_revid)
 
1660
        for hook in hooks:
 
1661
            hook(params)
 
1662
 
1108
1663
    @needs_write_lock
1109
 
    def update_revisions(self, other, stop_revision=None):
1110
 
        """See Branch.update_revisions."""
1111
 
        other.lock_read()
1112
 
        try:
1113
 
            if stop_revision is None:
1114
 
                stop_revision = other.last_revision()
1115
 
                if stop_revision is None:
1116
 
                    # if there are no commits, we're done.
1117
 
                    return
1118
 
            # whats the current last revision, before we fetch [and change it
1119
 
            # possibly]
1120
 
            last_rev = self.last_revision()
1121
 
            # we fetch here regardless of whether we need to so that we pickup
1122
 
            # filled in ghosts.
1123
 
            self.fetch(other, stop_revision)
1124
 
            my_ancestry = self.repository.get_ancestry(last_rev)
1125
 
            if stop_revision in my_ancestry:
1126
 
                # last_revision is a descendant of stop_revision
1127
 
                return
1128
 
            # stop_revision must be a descendant of last_revision
1129
 
            stop_graph = self.repository.get_revision_graph(stop_revision)
1130
 
            if last_rev is not None and last_rev not in stop_graph:
 
1664
    def set_last_revision_info(self, revno, revision_id):
 
1665
        """Set the last revision of this branch.
 
1666
 
 
1667
        The caller is responsible for checking that the revno is correct
 
1668
        for this revision id.
 
1669
 
 
1670
        It may be possible to set the branch last revision to an id not
 
1671
        present in the repository.  However, branches can also be 
 
1672
        configured to check constraints on history, in which case this may not
 
1673
        be permitted.
 
1674
        """
 
1675
        revision_id = _mod_revision.ensure_null(revision_id)
 
1676
        # this old format stores the full history, but this api doesn't
 
1677
        # provide it, so we must generate, and might as well check it's
 
1678
        # correct
 
1679
        history = self._lefthand_history(revision_id)
 
1680
        if len(history) != revno:
 
1681
            raise AssertionError('%d != %d' % (len(history), revno))
 
1682
        self.set_revision_history(history)
 
1683
 
 
1684
    def _gen_revision_history(self):
 
1685
        history = self._transport.get_bytes('revision-history').split('\n')
 
1686
        if history[-1:] == ['']:
 
1687
            # There shouldn't be a trailing newline, but just in case.
 
1688
            history.pop()
 
1689
        return history
 
1690
 
 
1691
    def _lefthand_history(self, revision_id, last_rev=None,
 
1692
                          other_branch=None):
 
1693
        if 'evil' in debug.debug_flags:
 
1694
            mutter_callsite(4, "_lefthand_history scales with history.")
 
1695
        # stop_revision must be a descendant of last_revision
 
1696
        graph = self.repository.get_graph()
 
1697
        if last_rev is not None:
 
1698
            if not graph.is_ancestor(last_rev, revision_id):
1131
1699
                # our previous tip is not merged into stop_revision
1132
 
                raise errors.DivergedBranches(self, other)
1133
 
            # make a new revision history from the graph
1134
 
            current_rev_id = stop_revision
1135
 
            new_history = []
1136
 
            while current_rev_id not in (None, NULL_REVISION):
1137
 
                new_history.append(current_rev_id)
1138
 
                current_rev_id_parents = stop_graph[current_rev_id]
1139
 
                try:
1140
 
                    current_rev_id = current_rev_id_parents[0]
1141
 
                except IndexError:
1142
 
                    current_rev_id = None
1143
 
            new_history.reverse()
1144
 
            self.set_revision_history(new_history)
1145
 
        finally:
1146
 
            other.unlock()
 
1700
                raise errors.DivergedBranches(self, other_branch)
 
1701
        # make a new revision history from the graph
 
1702
        parents_map = graph.get_parent_map([revision_id])
 
1703
        if revision_id not in parents_map:
 
1704
            raise errors.NoSuchRevision(self, revision_id)
 
1705
        current_rev_id = revision_id
 
1706
        new_history = []
 
1707
        check_not_reserved_id = _mod_revision.check_not_reserved_id
 
1708
        # Do not include ghosts or graph origin in revision_history
 
1709
        while (current_rev_id in parents_map and
 
1710
               len(parents_map[current_rev_id]) > 0):
 
1711
            check_not_reserved_id(current_rev_id)
 
1712
            new_history.append(current_rev_id)
 
1713
            current_rev_id = parents_map[current_rev_id][0]
 
1714
            parents_map = graph.get_parent_map([current_rev_id])
 
1715
        new_history.reverse()
 
1716
        return new_history
 
1717
 
 
1718
    @needs_write_lock
 
1719
    def generate_revision_history(self, revision_id, last_rev=None,
 
1720
        other_branch=None):
 
1721
        """Create a new revision history that will finish with revision_id.
 
1722
 
 
1723
        :param revision_id: the new tip to use.
 
1724
        :param last_rev: The previous last_revision. If not None, then this
 
1725
            must be a ancestory of revision_id, or DivergedBranches is raised.
 
1726
        :param other_branch: The other branch that DivergedBranches should
 
1727
            raise with respect to.
 
1728
        """
 
1729
        self.set_revision_history(self._lefthand_history(revision_id,
 
1730
            last_rev, other_branch))
1147
1731
 
1148
1732
    def basis_tree(self):
1149
1733
        """See Branch.basis_tree."""
1150
1734
        return self.repository.revision_tree(self.last_revision())
1151
1735
 
1152
 
    @deprecated_method(zero_eight)
1153
 
    def working_tree(self):
1154
 
        """Create a Working tree object for this branch."""
1155
 
        from bzrlib.workingtree import WorkingTree
1156
 
        from bzrlib.transport.local import LocalTransport
1157
 
        if (self.base.find('://') != -1 or 
1158
 
            not isinstance(self._transport, LocalTransport)):
1159
 
            raise NoWorkingTree(self.base)
1160
 
        return self.bzrdir.open_workingtree()
1161
 
 
1162
1736
    @needs_write_lock
1163
 
    def pull(self, source, overwrite=False, stop_revision=None):
1164
 
        """See Branch.pull."""
 
1737
    def pull(self, source, overwrite=False, stop_revision=None,
 
1738
             _hook_master=None, run_hooks=True, possible_transports=None,
 
1739
             _override_hook_target=None):
 
1740
        """See Branch.pull.
 
1741
 
 
1742
        :param _hook_master: Private parameter - set the branch to 
 
1743
            be supplied as the master to pull hooks.
 
1744
        :param run_hooks: Private parameter - if false, this branch
 
1745
            is being called because it's the master of the primary branch,
 
1746
            so it should not run its hooks.
 
1747
        :param _override_hook_target: Private parameter - set the branch to be
 
1748
            supplied as the target_branch to pull hooks.
 
1749
        """
 
1750
        result = PullResult()
 
1751
        result.source_branch = source
 
1752
        if _override_hook_target is None:
 
1753
            result.target_branch = self
 
1754
        else:
 
1755
            result.target_branch = _override_hook_target
1165
1756
        source.lock_read()
1166
1757
        try:
1167
 
            old_count = len(self.revision_history())
1168
 
            try:
1169
 
                self.update_revisions(source,stop_revision)
1170
 
            except DivergedBranches:
1171
 
                if not overwrite:
1172
 
                    raise
1173
 
            if overwrite:
1174
 
                self.set_revision_history(source.revision_history())
1175
 
            new_count = len(self.revision_history())
1176
 
            return new_count - old_count
 
1758
            # We assume that during 'pull' the local repository is closer than
 
1759
            # the remote one.
 
1760
            graph = self.repository.get_graph(source.repository)
 
1761
            result.old_revno, result.old_revid = self.last_revision_info()
 
1762
            self.update_revisions(source, stop_revision, overwrite=overwrite,
 
1763
                                  graph=graph)
 
1764
            result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)
 
1765
            result.new_revno, result.new_revid = self.last_revision_info()
 
1766
            if _hook_master:
 
1767
                result.master_branch = _hook_master
 
1768
                result.local_branch = result.target_branch
 
1769
            else:
 
1770
                result.master_branch = result.target_branch
 
1771
                result.local_branch = None
 
1772
            if run_hooks:
 
1773
                for hook in Branch.hooks['post_pull']:
 
1774
                    hook(result)
1177
1775
        finally:
1178
1776
            source.unlock()
 
1777
        return result
1179
1778
 
1180
 
    def get_parent(self):
1181
 
        """See Branch.get_parent."""
1182
 
        import errno
 
1779
    def _get_parent_location(self):
1183
1780
        _locs = ['parent', 'pull', 'x-pull']
1184
 
        assert self.base[-1] == '/'
1185
1781
        for l in _locs:
1186
1782
            try:
1187
 
                return urlutils.join(self.base[:-1], 
1188
 
                            self.control_files.get(l).read().strip('\n'))
1189
 
            except NoSuchFile:
 
1783
                return self._transport.get_bytes(l).strip('\n')
 
1784
            except errors.NoSuchFile:
1190
1785
                pass
1191
1786
        return None
1192
1787
 
1193
 
    def get_push_location(self):
1194
 
        """See Branch.get_push_location."""
1195
 
        config = bzrlib.config.BranchConfig(self)
1196
 
        push_loc = config.get_user_option('push_location')
1197
 
        return push_loc
 
1788
    @needs_read_lock
 
1789
    def push(self, target, overwrite=False, stop_revision=None,
 
1790
             _override_hook_source_branch=None):
 
1791
        """See Branch.push.
 
1792
 
 
1793
        This is the basic concrete implementation of push()
 
1794
 
 
1795
        :param _override_hook_source_branch: If specified, run
 
1796
        the hooks passing this Branch as the source, rather than self.  
 
1797
        This is for use of RemoteBranch, where push is delegated to the
 
1798
        underlying vfs-based Branch. 
 
1799
        """
 
1800
        # TODO: Public option to disable running hooks - should be trivial but
 
1801
        # needs tests.
 
1802
        return _run_with_write_locked_target(
 
1803
            target, self._push_with_bound_branches, target, overwrite,
 
1804
            stop_revision,
 
1805
            _override_hook_source_branch=_override_hook_source_branch)
 
1806
 
 
1807
    def _push_with_bound_branches(self, target, overwrite,
 
1808
            stop_revision,
 
1809
            _override_hook_source_branch=None):
 
1810
        """Push from self into target, and into target's master if any.
 
1811
        
 
1812
        This is on the base BzrBranch class even though it doesn't support 
 
1813
        bound branches because the *target* might be bound.
 
1814
        """
 
1815
        def _run_hooks():
 
1816
            if _override_hook_source_branch:
 
1817
                result.source_branch = _override_hook_source_branch
 
1818
            for hook in Branch.hooks['post_push']:
 
1819
                hook(result)
 
1820
 
 
1821
        bound_location = target.get_bound_location()
 
1822
        if bound_location and target.base != bound_location:
 
1823
            # there is a master branch.
 
1824
            #
 
1825
            # XXX: Why the second check?  Is it even supported for a branch to
 
1826
            # be bound to itself? -- mbp 20070507
 
1827
            master_branch = target.get_master_branch()
 
1828
            master_branch.lock_write()
 
1829
            try:
 
1830
                # push into the master from this branch.
 
1831
                self._basic_push(master_branch, overwrite, stop_revision)
 
1832
                # and push into the target branch from this. Note that we push from
 
1833
                # this branch again, because its considered the highest bandwidth
 
1834
                # repository.
 
1835
                result = self._basic_push(target, overwrite, stop_revision)
 
1836
                result.master_branch = master_branch
 
1837
                result.local_branch = target
 
1838
                _run_hooks()
 
1839
                return result
 
1840
            finally:
 
1841
                master_branch.unlock()
 
1842
        else:
 
1843
            # no master branch
 
1844
            result = self._basic_push(target, overwrite, stop_revision)
 
1845
            # TODO: Why set master_branch and local_branch if there's no
 
1846
            # binding?  Maybe cleaner to just leave them unset? -- mbp
 
1847
            # 20070504
 
1848
            result.master_branch = target
 
1849
            result.local_branch = None
 
1850
            _run_hooks()
 
1851
            return result
 
1852
 
 
1853
    def _basic_push(self, target, overwrite, stop_revision):
 
1854
        """Basic implementation of push without bound branches or hooks.
 
1855
 
 
1856
        Must be called with self read locked and target write locked.
 
1857
        """
 
1858
        result = PushResult()
 
1859
        result.source_branch = self
 
1860
        result.target_branch = target
 
1861
        result.old_revno, result.old_revid = target.last_revision_info()
 
1862
        if result.old_revid != self.last_revision():
 
1863
            # We assume that during 'push' this repository is closer than
 
1864
            # the target.
 
1865
            graph = self.repository.get_graph(target.repository)
 
1866
            target.update_revisions(self, stop_revision, overwrite=overwrite,
 
1867
                                    graph=graph)
 
1868
        if self._push_should_merge_tags():
 
1869
            result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
 
1870
        result.new_revno, result.new_revid = target.last_revision_info()
 
1871
        return result
 
1872
 
 
1873
    def _push_should_merge_tags(self):
 
1874
        """Should _basic_push merge this branch's tags into the target?
 
1875
        
 
1876
        The default implementation returns False if this branch has no tags,
 
1877
        and True the rest of the time.  Subclasses may override this.
 
1878
        """
 
1879
        return self.tags.supports_tags() and self.tags.get_tag_dict()
 
1880
 
 
1881
    def get_parent(self):
 
1882
        """See Branch.get_parent."""
 
1883
        parent = self._get_parent_location()
 
1884
        if parent is None:
 
1885
            return parent
 
1886
        # This is an old-format absolute path to a local branch
 
1887
        # turn it into a url
 
1888
        if parent.startswith('/'):
 
1889
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
 
1890
        try:
 
1891
            return urlutils.join(self.base[:-1], parent)
 
1892
        except errors.InvalidURLJoin, e:
 
1893
            raise errors.InaccessibleParent(parent, self.base)
 
1894
 
 
1895
    def get_stacked_on_url(self):
 
1896
        raise errors.UnstackableBranchFormat(self._format, self.base)
1198
1897
 
1199
1898
    def set_push_location(self, location):
1200
1899
        """See Branch.set_push_location."""
1201
 
        config = bzrlib.config.LocationConfig(self.base)
1202
 
        config.set_user_option('push_location', location)
 
1900
        self.get_config().set_user_option(
 
1901
            'push_location', location,
 
1902
            store=_mod_config.STORE_LOCATION_NORECURSE)
1203
1903
 
1204
1904
    @needs_write_lock
1205
1905
    def set_parent(self, url):
1207
1907
        # TODO: Maybe delete old location files?
1208
1908
        # URLs should never be unicode, even on the local fs,
1209
1909
        # FIXUP this and get_parent in a future branch format bump:
1210
 
        # read and rewrite the file, and have the new format code read
1211
 
        # using .get not .get_utf8. RBC 20060125
1212
 
        if url is None:
1213
 
            self.control_files._transport.delete('parent')
1214
 
        else:
 
1910
        # read and rewrite the file. RBC 20060125
 
1911
        if url is not None:
1215
1912
            if isinstance(url, unicode):
1216
 
                try: 
 
1913
                try:
1217
1914
                    url = url.encode('ascii')
1218
1915
                except UnicodeEncodeError:
1219
 
                    raise bzrlib.errors.InvalidURL(url,
 
1916
                    raise errors.InvalidURL(url,
1220
1917
                        "Urls must be 7-bit ascii, "
1221
1918
                        "use bzrlib.urlutils.escape")
1222
 
                    
1223
1919
            url = urlutils.relative_url(self.base, url)
1224
 
            self.control_files.put('parent', url + '\n')
1225
 
 
1226
 
    def tree_config(self):
1227
 
        return TreeConfig(self)
 
1920
        self._set_parent_location(url)
 
1921
 
 
1922
    def _set_parent_location(self, url):
 
1923
        if url is None:
 
1924
            self._transport.delete('parent')
 
1925
        else:
 
1926
            self._transport.put_bytes('parent', url + '\n',
 
1927
                mode=self.bzrdir._get_file_mode())
 
1928
 
 
1929
    def set_stacked_on_url(self, url):
 
1930
        raise errors.UnstackableBranchFormat(self._format, self.base)
1228
1931
 
1229
1932
 
1230
1933
class BzrBranch5(BzrBranch):
1231
 
    """A format 5 branch. This supports new features over plan branches.
 
1934
    """A format 5 branch. This supports new features over plain branches.
1232
1935
 
1233
1936
    It has support for a master_branch which is the data for bound branches.
1234
1937
    """
1235
1938
 
1236
 
    def __init__(self,
1237
 
                 _format,
1238
 
                 _control_files,
1239
 
                 a_bzrdir,
1240
 
                 _repository):
1241
 
        super(BzrBranch5, self).__init__(_format=_format,
1242
 
                                         _control_files=_control_files,
1243
 
                                         a_bzrdir=a_bzrdir,
1244
 
                                         _repository=_repository)
 
1939
    @needs_write_lock
 
1940
    def pull(self, source, overwrite=False, stop_revision=None,
 
1941
             run_hooks=True, possible_transports=None,
 
1942
             _override_hook_target=None):
 
1943
        """Pull from source into self, updating my master if any.
1245
1944
        
1246
 
    @needs_write_lock
1247
 
    def pull(self, source, overwrite=False, stop_revision=None):
1248
 
        """Updates branch.pull to be bound branch aware."""
 
1945
        :param run_hooks: Private parameter - if false, this branch
 
1946
            is being called because it's the master of the primary branch,
 
1947
            so it should not run its hooks.
 
1948
        """
1249
1949
        bound_location = self.get_bound_location()
1250
 
        if source.base != bound_location:
 
1950
        master_branch = None
 
1951
        if bound_location and source.base != bound_location:
1251
1952
            # not pulling from master, so we need to update master.
1252
 
            master_branch = self.get_master_branch()
1253
 
            if master_branch:
1254
 
                master_branch.pull(source)
1255
 
                source = master_branch
1256
 
        return super(BzrBranch5, self).pull(source, overwrite, stop_revision)
 
1953
            master_branch = self.get_master_branch(possible_transports)
 
1954
            master_branch.lock_write()
 
1955
        try:
 
1956
            if master_branch:
 
1957
                # pull from source into master.
 
1958
                master_branch.pull(source, overwrite, stop_revision,
 
1959
                    run_hooks=False)
 
1960
            return super(BzrBranch5, self).pull(source, overwrite,
 
1961
                stop_revision, _hook_master=master_branch,
 
1962
                run_hooks=run_hooks,
 
1963
                _override_hook_target=_override_hook_target)
 
1964
        finally:
 
1965
            if master_branch:
 
1966
                master_branch.unlock()
1257
1967
 
1258
1968
    def get_bound_location(self):
1259
1969
        try:
1260
 
            return self.control_files.get_utf8('bound').read()[:-1]
 
1970
            return self._transport.get_bytes('bound')[:-1]
1261
1971
        except errors.NoSuchFile:
1262
1972
            return None
1263
1973
 
1264
1974
    @needs_read_lock
1265
 
    def get_master_branch(self):
 
1975
    def get_master_branch(self, possible_transports=None):
1266
1976
        """Return the branch we are bound to.
1267
1977
        
1268
1978
        :return: Either a Branch, or None
1276
1986
        if not bound_loc:
1277
1987
            return None
1278
1988
        try:
1279
 
            return Branch.open(bound_loc)
 
1989
            return Branch.open(bound_loc,
 
1990
                               possible_transports=possible_transports)
1280
1991
        except (errors.NotBranchError, errors.ConnectionError), e:
1281
1992
            raise errors.BoundBranchConnectionFailure(
1282
1993
                    self, bound_loc, e)
1288
1999
        :param location: URL to the target branch
1289
2000
        """
1290
2001
        if location:
1291
 
            self.control_files.put_utf8('bound', location+'\n')
 
2002
            self._transport.put_bytes('bound', location+'\n',
 
2003
                mode=self.bzrdir._get_file_mode())
1292
2004
        else:
1293
2005
            try:
1294
 
                self.control_files._transport.delete('bound')
1295
 
            except NoSuchFile:
 
2006
                self._transport.delete('bound')
 
2007
            except errors.NoSuchFile:
1296
2008
                return False
1297
2009
            return True
1298
2010
 
1299
2011
    @needs_write_lock
1300
2012
    def bind(self, other):
1301
 
        """Bind the local branch the other branch.
 
2013
        """Bind this branch to the branch other.
1302
2014
 
 
2015
        This does not push or pull data between the branches, though it does
 
2016
        check for divergence to raise an error when the branches are not
 
2017
        either the same, or one a prefix of the other. That behaviour may not
 
2018
        be useful, so that check may be removed in future.
 
2019
        
1303
2020
        :param other: The branch to bind to
1304
2021
        :type other: Branch
1305
2022
        """
1310
2027
        #       but binding itself may not be.
1311
2028
        #       Since we *have* to check at commit time, we don't
1312
2029
        #       *need* to check here
1313
 
        self.pull(other)
1314
 
 
1315
 
        # we are now equal to or a suffix of other.
1316
 
 
1317
 
        # Since we have 'pulled' from the remote location,
1318
 
        # now we should try to pull in the opposite direction
1319
 
        # in case the local tree has more revisions than the
1320
 
        # remote one.
1321
 
        # There may be a different check you could do here
1322
 
        # rather than actually trying to install revisions remotely.
1323
 
        # TODO: capture an exception which indicates the remote branch
1324
 
        #       is not writable. 
1325
 
        #       If it is up-to-date, this probably should not be a failure
1326
 
        
1327
 
        # lock other for write so the revision-history syncing cannot race
1328
 
        other.lock_write()
1329
 
        try:
1330
 
            other.pull(self)
1331
 
            # if this does not error, other now has the same last rev we do
1332
 
            # it can only error if the pull from other was concurrent with
1333
 
            # a commit to other from someone else.
1334
 
 
1335
 
            # until we ditch revision-history, we need to sync them up:
1336
 
            self.set_revision_history(other.revision_history())
1337
 
            # now other and self are up to date with each other and have the
1338
 
            # same revision-history.
1339
 
        finally:
1340
 
            other.unlock()
1341
 
 
 
2030
 
 
2031
        # we want to raise diverged if:
 
2032
        # last_rev is not in the other_last_rev history, AND
 
2033
        # other_last_rev is not in our history, and do it without pulling
 
2034
        # history around
1342
2035
        self.set_bound_location(other.base)
1343
2036
 
1344
2037
    @needs_write_lock
1347
2040
        return self.set_bound_location(None)
1348
2041
 
1349
2042
    @needs_write_lock
1350
 
    def update(self):
 
2043
    def update(self, possible_transports=None):
1351
2044
        """Synchronise this branch with the master branch if any. 
1352
2045
 
1353
2046
        :return: None or the last_revision that was pivoted out during the
1354
2047
                 update.
1355
2048
        """
1356
 
        master = self.get_master_branch()
 
2049
        master = self.get_master_branch(possible_transports)
1357
2050
        if master is not None:
1358
 
            old_tip = self.last_revision()
 
2051
            old_tip = _mod_revision.ensure_null(self.last_revision())
1359
2052
            self.pull(master, overwrite=True)
1360
 
            if old_tip in self.repository.get_ancestry(self.last_revision()):
 
2053
            if self.repository.get_graph().is_ancestor(old_tip,
 
2054
                _mod_revision.ensure_null(self.last_revision())):
1361
2055
                return None
1362
2056
            return old_tip
1363
2057
        return None
1364
2058
 
1365
2059
 
1366
 
class BranchTestProviderAdapter(object):
1367
 
    """A tool to generate a suite testing multiple branch formats at once.
1368
 
 
1369
 
    This is done by copying the test once for each transport and injecting
1370
 
    the transport_server, transport_readonly_server, and branch_format
1371
 
    classes into each copy. Each copy is also given a new id() to make it
1372
 
    easy to identify.
1373
 
    """
1374
 
 
1375
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1376
 
        self._transport_server = transport_server
1377
 
        self._transport_readonly_server = transport_readonly_server
1378
 
        self._formats = formats
1379
 
    
1380
 
    def adapt(self, test):
1381
 
        result = TestSuite()
1382
 
        for branch_format, bzrdir_format in self._formats:
1383
 
            new_test = deepcopy(test)
1384
 
            new_test.transport_server = self._transport_server
1385
 
            new_test.transport_readonly_server = self._transport_readonly_server
1386
 
            new_test.bzrdir_format = bzrdir_format
1387
 
            new_test.branch_format = branch_format
1388
 
            def make_new_test_id():
1389
 
                new_id = "%s(%s)" % (new_test.id(), branch_format.__class__.__name__)
1390
 
                return lambda: new_id
1391
 
            new_test.id = make_new_test_id()
1392
 
            result.addTest(new_test)
1393
 
        return result
 
2060
class BzrBranch7(BzrBranch5):
 
2061
    """A branch with support for a fallback repository."""
 
2062
 
 
2063
    def _get_fallback_repository(self, url):
 
2064
        """Get the repository we fallback to at url."""
 
2065
        url = urlutils.join(self.base, url)
 
2066
        a_bzrdir = bzrdir.BzrDir.open(url,
 
2067
                                      possible_transports=[self._transport])
 
2068
        return a_bzrdir.open_branch().repository
 
2069
 
 
2070
    def _activate_fallback_location(self, url):
 
2071
        """Activate the branch/repository from url as a fallback repository."""
 
2072
        self.repository.add_fallback_repository(
 
2073
            self._get_fallback_repository(url))
 
2074
 
 
2075
    def _open_hook(self):
 
2076
        try:
 
2077
            url = self.get_stacked_on_url()
 
2078
        except (errors.UnstackableRepositoryFormat, errors.NotStacked,
 
2079
            errors.UnstackableBranchFormat):
 
2080
            pass
 
2081
        else:
 
2082
            for hook in Branch.hooks['transform_fallback_location']:
 
2083
                url = hook(self, url)
 
2084
                if url is None:
 
2085
                    hook_name = Branch.hooks.get_hook_name(hook)
 
2086
                    raise AssertionError(
 
2087
                        "'transform_fallback_location' hook %s returned "
 
2088
                        "None, not a URL." % hook_name)
 
2089
            self._activate_fallback_location(url)
 
2090
 
 
2091
    def _check_stackable_repo(self):
 
2092
        if not self.repository._format.supports_external_lookups:
 
2093
            raise errors.UnstackableRepositoryFormat(self.repository._format,
 
2094
                self.repository.base)
 
2095
 
 
2096
    def __init__(self, *args, **kwargs):
 
2097
        super(BzrBranch7, self).__init__(*args, **kwargs)
 
2098
        self._last_revision_info_cache = None
 
2099
        self._partial_revision_history_cache = []
 
2100
 
 
2101
    def _clear_cached_state(self):
 
2102
        super(BzrBranch7, self)._clear_cached_state()
 
2103
        self._last_revision_info_cache = None
 
2104
        self._partial_revision_history_cache = []
 
2105
 
 
2106
    def _last_revision_info(self):
 
2107
        revision_string = self._transport.get_bytes('last-revision')
 
2108
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
 
2109
        revision_id = cache_utf8.get_cached_utf8(revision_id)
 
2110
        revno = int(revno)
 
2111
        return revno, revision_id
 
2112
 
 
2113
    def _write_last_revision_info(self, revno, revision_id):
 
2114
        """Simply write out the revision id, with no checks.
 
2115
 
 
2116
        Use set_last_revision_info to perform this safely.
 
2117
 
 
2118
        Does not update the revision_history cache.
 
2119
        Intended to be called by set_last_revision_info and
 
2120
        _write_revision_history.
 
2121
        """
 
2122
        revision_id = _mod_revision.ensure_null(revision_id)
 
2123
        out_string = '%d %s\n' % (revno, revision_id)
 
2124
        self._transport.put_bytes('last-revision', out_string,
 
2125
            mode=self.bzrdir._get_file_mode())
 
2126
 
 
2127
    @needs_write_lock
 
2128
    def set_last_revision_info(self, revno, revision_id):
 
2129
        revision_id = _mod_revision.ensure_null(revision_id)
 
2130
        old_revno, old_revid = self.last_revision_info()
 
2131
        if self._get_append_revisions_only():
 
2132
            self._check_history_violation(revision_id)
 
2133
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
 
2134
        self._write_last_revision_info(revno, revision_id)
 
2135
        self._clear_cached_state()
 
2136
        self._last_revision_info_cache = revno, revision_id
 
2137
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
 
2138
 
 
2139
    def _synchronize_history(self, destination, revision_id):
 
2140
        """Synchronize last revision and revision history between branches.
 
2141
        
 
2142
        :see: Branch._synchronize_history
 
2143
        """
 
2144
        # XXX: The base Branch has a fast implementation of this method based
 
2145
        # on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
 
2146
        # that uses set_revision_history.  This class inherits from BzrBranch5,
 
2147
        # but wants the fast implementation, so it calls
 
2148
        # Branch._synchronize_history directly.
 
2149
        Branch._synchronize_history(self, destination, revision_id)
 
2150
 
 
2151
    def _check_history_violation(self, revision_id):
 
2152
        last_revision = _mod_revision.ensure_null(self.last_revision())
 
2153
        if _mod_revision.is_null(last_revision):
 
2154
            return
 
2155
        if last_revision not in self._lefthand_history(revision_id):
 
2156
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
2157
 
 
2158
    def _gen_revision_history(self):
 
2159
        """Generate the revision history from last revision
 
2160
        """
 
2161
        last_revno, last_revision = self.last_revision_info()
 
2162
        self._extend_partial_history(stop_index=last_revno-1)
 
2163
        return list(reversed(self._partial_revision_history_cache))
 
2164
 
 
2165
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
 
2166
        """Extend the partial history to include a given index
 
2167
 
 
2168
        If a stop_index is supplied, stop when that index has been reached.
 
2169
        If a stop_revision is supplied, stop when that revision is
 
2170
        encountered.  Otherwise, stop when the beginning of history is
 
2171
        reached.
 
2172
 
 
2173
        :param stop_index: The index which should be present.  When it is
 
2174
            present, history extension will stop.
 
2175
        :param revision_id: The revision id which should be present.  When
 
2176
            it is encountered, history extension will stop.
 
2177
        """
 
2178
        repo = self.repository
 
2179
        if len(self._partial_revision_history_cache) == 0:
 
2180
            iterator = repo.iter_reverse_revision_history(self.last_revision())
 
2181
        else:
 
2182
            start_revision = self._partial_revision_history_cache[-1]
 
2183
            iterator = repo.iter_reverse_revision_history(start_revision)
 
2184
            #skip the last revision in the list
 
2185
            next_revision = iterator.next()
 
2186
        for revision_id in iterator:
 
2187
            self._partial_revision_history_cache.append(revision_id)
 
2188
            if (stop_index is not None and
 
2189
                len(self._partial_revision_history_cache) > stop_index):
 
2190
                break
 
2191
            if revision_id == stop_revision:
 
2192
                break
 
2193
 
 
2194
    def _write_revision_history(self, history):
 
2195
        """Factored out of set_revision_history.
 
2196
 
 
2197
        This performs the actual writing to disk, with format-specific checks.
 
2198
        It is intended to be called by BzrBranch5.set_revision_history.
 
2199
        """
 
2200
        if len(history) == 0:
 
2201
            last_revision = 'null:'
 
2202
        else:
 
2203
            if history != self._lefthand_history(history[-1]):
 
2204
                raise errors.NotLefthandHistory(history)
 
2205
            last_revision = history[-1]
 
2206
        if self._get_append_revisions_only():
 
2207
            self._check_history_violation(last_revision)
 
2208
        self._write_last_revision_info(len(history), last_revision)
 
2209
 
 
2210
    @needs_write_lock
 
2211
    def _set_parent_location(self, url):
 
2212
        """Set the parent branch"""
 
2213
        self._set_config_location('parent_location', url, make_relative=True)
 
2214
 
 
2215
    @needs_read_lock
 
2216
    def _get_parent_location(self):
 
2217
        """Set the parent branch"""
 
2218
        return self._get_config_location('parent_location')
 
2219
 
 
2220
    def set_push_location(self, location):
 
2221
        """See Branch.set_push_location."""
 
2222
        self._set_config_location('push_location', location)
 
2223
 
 
2224
    def set_bound_location(self, location):
 
2225
        """See Branch.set_push_location."""
 
2226
        result = None
 
2227
        config = self.get_config()
 
2228
        if location is None:
 
2229
            if config.get_user_option('bound') != 'True':
 
2230
                return False
 
2231
            else:
 
2232
                config.set_user_option('bound', 'False', warn_masked=True)
 
2233
                return True
 
2234
        else:
 
2235
            self._set_config_location('bound_location', location,
 
2236
                                      config=config)
 
2237
            config.set_user_option('bound', 'True', warn_masked=True)
 
2238
        return True
 
2239
 
 
2240
    def _get_bound_location(self, bound):
 
2241
        """Return the bound location in the config file.
 
2242
 
 
2243
        Return None if the bound parameter does not match"""
 
2244
        config = self.get_config()
 
2245
        config_bound = (config.get_user_option('bound') == 'True')
 
2246
        if config_bound != bound:
 
2247
            return None
 
2248
        return self._get_config_location('bound_location', config=config)
 
2249
 
 
2250
    def get_bound_location(self):
 
2251
        """See Branch.set_push_location."""
 
2252
        return self._get_bound_location(True)
 
2253
 
 
2254
    def get_old_bound_location(self):
 
2255
        """See Branch.get_old_bound_location"""
 
2256
        return self._get_bound_location(False)
 
2257
 
 
2258
    def get_stacked_on_url(self):
 
2259
        # you can always ask for the URL; but you might not be able to use it
 
2260
        # if the repo can't support stacking.
 
2261
        ## self._check_stackable_repo()
 
2262
        stacked_url = self._get_config_location('stacked_on_location')
 
2263
        if stacked_url is None:
 
2264
            raise errors.NotStacked(self)
 
2265
        return stacked_url
 
2266
 
 
2267
    def set_append_revisions_only(self, enabled):
 
2268
        if enabled:
 
2269
            value = 'True'
 
2270
        else:
 
2271
            value = 'False'
 
2272
        self.get_config().set_user_option('append_revisions_only', value,
 
2273
            warn_masked=True)
 
2274
 
 
2275
    def set_stacked_on_url(self, url):
 
2276
        self._check_stackable_repo()
 
2277
        if not url:
 
2278
            try:
 
2279
                old_url = self.get_stacked_on_url()
 
2280
            except (errors.NotStacked, errors.UnstackableBranchFormat,
 
2281
                errors.UnstackableRepositoryFormat):
 
2282
                return
 
2283
            url = ''
 
2284
            # repositories don't offer an interface to remove fallback
 
2285
            # repositories today; take the conceptually simpler option and just
 
2286
            # reopen it.
 
2287
            self.repository = self.bzrdir.find_repository()
 
2288
            # for every revision reference the branch has, ensure it is pulled
 
2289
            # in.
 
2290
            source_repository = self._get_fallback_repository(old_url)
 
2291
            for revision_id in chain([self.last_revision()],
 
2292
                self.tags.get_reverse_tag_dict()):
 
2293
                self.repository.fetch(source_repository, revision_id,
 
2294
                    find_ghosts=True)
 
2295
        else:
 
2296
            self._activate_fallback_location(url)
 
2297
        # write this out after the repository is stacked to avoid setting a
 
2298
        # stacked config that doesn't work.
 
2299
        self._set_config_location('stacked_on_location', url)
 
2300
 
 
2301
    def _get_append_revisions_only(self):
 
2302
        value = self.get_config().get_user_option('append_revisions_only')
 
2303
        return value == 'True'
 
2304
 
 
2305
    def _make_tags(self):
 
2306
        return BasicTags(self)
 
2307
 
 
2308
    @needs_write_lock
 
2309
    def generate_revision_history(self, revision_id, last_rev=None,
 
2310
                                  other_branch=None):
 
2311
        """See BzrBranch5.generate_revision_history"""
 
2312
        history = self._lefthand_history(revision_id, last_rev, other_branch)
 
2313
        revno = len(history)
 
2314
        self.set_last_revision_info(revno, revision_id)
 
2315
 
 
2316
    @needs_read_lock
 
2317
    def get_rev_id(self, revno, history=None):
 
2318
        """Find the revision id of the specified revno."""
 
2319
        if revno == 0:
 
2320
            return _mod_revision.NULL_REVISION
 
2321
 
 
2322
        last_revno, last_revision_id = self.last_revision_info()
 
2323
        if revno <= 0 or revno > last_revno:
 
2324
            raise errors.NoSuchRevision(self, revno)
 
2325
 
 
2326
        if history is not None:
 
2327
            return history[revno - 1]
 
2328
 
 
2329
        index = last_revno - revno
 
2330
        if len(self._partial_revision_history_cache) <= index:
 
2331
            self._extend_partial_history(stop_index=index)
 
2332
        if len(self._partial_revision_history_cache) > index:
 
2333
            return self._partial_revision_history_cache[index]
 
2334
        else:
 
2335
            raise errors.NoSuchRevision(self, revno)
 
2336
 
 
2337
    @needs_read_lock
 
2338
    def revision_id_to_revno(self, revision_id):
 
2339
        """Given a revision id, return its revno"""
 
2340
        if _mod_revision.is_null(revision_id):
 
2341
            return 0
 
2342
        try:
 
2343
            index = self._partial_revision_history_cache.index(revision_id)
 
2344
        except ValueError:
 
2345
            self._extend_partial_history(stop_revision=revision_id)
 
2346
            index = len(self._partial_revision_history_cache) - 1
 
2347
            if self._partial_revision_history_cache[index] != revision_id:
 
2348
                raise errors.NoSuchRevision(self, revision_id)
 
2349
        return self.revno() - index
 
2350
 
 
2351
 
 
2352
class BzrBranch6(BzrBranch7):
 
2353
    """See BzrBranchFormat6 for the capabilities of this branch.
 
2354
 
 
2355
    This subclass of BzrBranch7 disables the new features BzrBranch7 added,
 
2356
    i.e. stacking.
 
2357
    """
 
2358
 
 
2359
    def get_stacked_on_url(self):
 
2360
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2361
 
 
2362
    def set_stacked_on_url(self, url):
 
2363
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2364
 
 
2365
 
 
2366
######################################################################
 
2367
# results of operations
 
2368
 
 
2369
 
 
2370
class _Result(object):
 
2371
 
 
2372
    def _show_tag_conficts(self, to_file):
 
2373
        if not getattr(self, 'tag_conflicts', None):
 
2374
            return
 
2375
        to_file.write('Conflicting tags:\n')
 
2376
        for name, value1, value2 in self.tag_conflicts:
 
2377
            to_file.write('    %s\n' % (name, ))
 
2378
 
 
2379
 
 
2380
class PullResult(_Result):
 
2381
    """Result of a Branch.pull operation.
 
2382
 
 
2383
    :ivar old_revno: Revision number before pull.
 
2384
    :ivar new_revno: Revision number after pull.
 
2385
    :ivar old_revid: Tip revision id before pull.
 
2386
    :ivar new_revid: Tip revision id after pull.
 
2387
    :ivar source_branch: Source (local) branch object.
 
2388
    :ivar master_branch: Master branch of the target, or the target if no
 
2389
        Master
 
2390
    :ivar local_branch: target branch if there is a Master, else None
 
2391
    :ivar target_branch: Target/destination branch object.
 
2392
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
 
2393
    """
 
2394
 
 
2395
    def __int__(self):
 
2396
        # DEPRECATED: pull used to return the change in revno
 
2397
        return self.new_revno - self.old_revno
 
2398
 
 
2399
    def report(self, to_file):
 
2400
        if not is_quiet():
 
2401
            if self.old_revid == self.new_revid:
 
2402
                to_file.write('No revisions to pull.\n')
 
2403
            else:
 
2404
                to_file.write('Now on revision %d.\n' % self.new_revno)
 
2405
        self._show_tag_conficts(to_file)
 
2406
 
 
2407
 
 
2408
class PushResult(_Result):
 
2409
    """Result of a Branch.push operation.
 
2410
 
 
2411
    :ivar old_revno: Revision number before push.
 
2412
    :ivar new_revno: Revision number after push.
 
2413
    :ivar old_revid: Tip revision id before push.
 
2414
    :ivar new_revid: Tip revision id after push.
 
2415
    :ivar source_branch: Source branch object.
 
2416
    :ivar master_branch: Master branch of the target, or None.
 
2417
    :ivar target_branch: Target/destination branch object.
 
2418
    """
 
2419
 
 
2420
    def __int__(self):
 
2421
        # DEPRECATED: push used to return the change in revno
 
2422
        return self.new_revno - self.old_revno
 
2423
 
 
2424
    def report(self, to_file):
 
2425
        """Write a human-readable description of the result."""
 
2426
        if self.old_revid == self.new_revid:
 
2427
            to_file.write('No new revisions to push.\n')
 
2428
        else:
 
2429
            to_file.write('Pushed up to revision %d.\n' % self.new_revno)
 
2430
        self._show_tag_conficts(to_file)
1394
2431
 
1395
2432
 
1396
2433
class BranchCheckResult(object):
1413
2450
             self.branch._format)
1414
2451
 
1415
2452
 
1416
 
######################################################################
1417
 
# predicates
1418
 
 
1419
 
 
1420
 
@deprecated_function(zero_eight)
1421
 
def ScratchBranch(*args, **kwargs):
1422
 
    """See bzrlib.bzrdir.ScratchDir."""
1423
 
    d = ScratchDir(*args, **kwargs)
1424
 
    return d.open_branch()
1425
 
 
1426
 
 
1427
 
@deprecated_function(zero_eight)
1428
 
def is_control_file(*args, **kwargs):
1429
 
    """See bzrlib.workingtree.is_control_file."""
1430
 
    return bzrlib.workingtree.is_control_file(*args, **kwargs)
 
2453
class Converter5to6(object):
 
2454
    """Perform an in-place upgrade of format 5 to format 6"""
 
2455
 
 
2456
    def convert(self, branch):
 
2457
        # Data for 5 and 6 can peacefully coexist.
 
2458
        format = BzrBranchFormat6()
 
2459
        new_branch = format.open(branch.bzrdir, _found=True)
 
2460
 
 
2461
        # Copy source data into target
 
2462
        new_branch._write_last_revision_info(*branch.last_revision_info())
 
2463
        new_branch.set_parent(branch.get_parent())
 
2464
        new_branch.set_bound_location(branch.get_bound_location())
 
2465
        new_branch.set_push_location(branch.get_push_location())
 
2466
 
 
2467
        # New branch has no tags by default
 
2468
        new_branch.tags._set_tag_dict({})
 
2469
 
 
2470
        # Copying done; now update target format
 
2471
        new_branch._transport.put_bytes('format',
 
2472
            format.get_format_string(),
 
2473
            mode=new_branch.bzrdir._get_file_mode())
 
2474
 
 
2475
        # Clean up old files
 
2476
        new_branch._transport.delete('revision-history')
 
2477
        try:
 
2478
            branch.set_parent(None)
 
2479
        except errors.NoSuchFile:
 
2480
            pass
 
2481
        branch.set_bound_location(None)
 
2482
 
 
2483
 
 
2484
class Converter6to7(object):
 
2485
    """Perform an in-place upgrade of format 6 to format 7"""
 
2486
 
 
2487
    def convert(self, branch):
 
2488
        format = BzrBranchFormat7()
 
2489
        branch._set_config_location('stacked_on_location', '')
 
2490
        # update target format
 
2491
        branch._transport.put_bytes('format', format.get_format_string())
 
2492
 
 
2493
 
 
2494
 
 
2495
def _run_with_write_locked_target(target, callable, *args, **kwargs):
 
2496
    """Run ``callable(*args, **kwargs)``, write-locking target for the
 
2497
    duration.
 
2498
 
 
2499
    _run_with_write_locked_target will attempt to release the lock it acquires.
 
2500
 
 
2501
    If an exception is raised by callable, then that exception *will* be
 
2502
    propagated, even if the unlock attempt raises its own error.  Thus
 
2503
    _run_with_write_locked_target should be preferred to simply doing::
 
2504
 
 
2505
        target.lock_write()
 
2506
        try:
 
2507
            return callable(*args, **kwargs)
 
2508
        finally:
 
2509
            target.unlock()
 
2510
    
 
2511
    """
 
2512
    # This is very similar to bzrlib.decorators.needs_write_lock.  Perhaps they
 
2513
    # should share code?
 
2514
    target.lock_write()
 
2515
    try:
 
2516
        result = callable(*args, **kwargs)
 
2517
    except:
 
2518
        exc_info = sys.exc_info()
 
2519
        try:
 
2520
            target.unlock()
 
2521
        finally:
 
2522
            raise exc_info[0], exc_info[1], exc_info[2]
 
2523
    else:
 
2524
        target.unlock()
 
2525
        return result