/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
from cStringIO import StringIO
19
 
import sys
20
19
 
21
20
from bzrlib.lazy_import import lazy_import
22
21
lazy_import(globals(), """
23
 
from itertools import chain
 
22
from copy import deepcopy
 
23
from unittest import TestSuite
 
24
from warnings import warn
 
25
 
 
26
import bzrlib
24
27
from bzrlib import (
25
28
        bzrdir,
26
29
        cache_utf8,
27
30
        config as _mod_config,
28
 
        debug,
29
31
        errors,
30
32
        lockdir,
31
33
        lockable_files,
32
 
        repository,
 
34
        osutils,
33
35
        revision as _mod_revision,
34
 
        rio,
35
 
        symbol_versioning,
36
36
        transport,
37
 
        tsort,
 
37
        tree,
38
38
        ui,
39
39
        urlutils,
40
40
        )
41
 
from bzrlib.config import BranchConfig, TransportConfig
42
 
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
 
41
from bzrlib.config import BranchConfig, TreeConfig
 
42
from bzrlib.lockable_files import LockableFiles, TransportLock
43
43
from bzrlib.tag import (
44
44
    BasicTags,
45
45
    DisabledTags,
46
46
    )
47
47
""")
48
48
 
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
50
 
from bzrlib.hooks import HookPoint, Hooks
51
 
from bzrlib.inter import InterObject
52
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
53
 
from bzrlib import registry
54
 
from bzrlib.symbol_versioning import (
55
 
    deprecated_in,
56
 
    deprecated_method,
57
 
    )
58
 
from bzrlib.trace import mutter, mutter_callsite, note, is_quiet
 
49
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
50
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
 
51
                           HistoryMissing, InvalidRevisionId,
 
52
                           InvalidRevisionNumber, LockError, NoSuchFile,
 
53
                           NoSuchRevision, NoWorkingTree, NotVersionedError,
 
54
                           NotBranchError, UninitializableFormat,
 
55
                           UnlistableStore, UnlistableBranch,
 
56
                           )
 
57
from bzrlib.hooks import Hooks
 
58
from bzrlib.symbol_versioning import (deprecated_function,
 
59
                                      deprecated_method,
 
60
                                      DEPRECATED_PARAMETER,
 
61
                                      deprecated_passed,
 
62
                                      zero_eight, zero_nine, zero_sixteen,
 
63
                                      )
 
64
from bzrlib.trace import mutter, note
59
65
 
60
66
 
61
67
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
63
69
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
64
70
 
65
71
 
66
 
class Branch(bzrdir.ControlComponent):
 
72
# TODO: Maybe include checks for common corruption of newlines, etc?
 
73
 
 
74
# TODO: Some operations like log might retrieve the same revisions
 
75
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
76
# cache in memory to make this faster.  In general anything can be
 
77
# cached in memory between lock and unlock operations. .. nb thats
 
78
# what the transaction identity map provides
 
79
 
 
80
 
 
81
######################################################################
 
82
# branch objects
 
83
 
 
84
class Branch(object):
67
85
    """Branch holding a history of revisions.
68
86
 
69
 
    :ivar base:
70
 
        Base directory/url of the branch; using control_url and
71
 
        control_transport is more standardized.
 
87
    base
 
88
        Base directory/url of the branch.
72
89
 
73
90
    hooks: An instance of BranchHooks.
74
91
    """
76
93
    # - RBC 20060112
77
94
    base = None
78
95
 
79
 
    @property
80
 
    def control_transport(self):
81
 
        return self._transport
82
 
 
83
 
    @property
84
 
    def user_transport(self):
85
 
        return self.bzrdir.user_transport
 
96
    # override this to set the strategy for storing tags
 
97
    def _make_tags(self):
 
98
        return DisabledTags(self)
86
99
 
87
100
    def __init__(self, *ignored, **ignored_too):
88
 
        self.tags = self._format.make_tags(self)
 
101
        self.tags = self._make_tags()
89
102
        self._revision_history_cache = None
90
 
        self._revision_id_to_revno_cache = None
91
 
        self._partial_revision_id_to_revno_cache = {}
92
 
        self._partial_revision_history_cache = []
93
 
        self._last_revision_info_cache = None
94
 
        self._merge_sorted_revisions_cache = None
95
 
        self._open_hook()
96
 
        hooks = Branch.hooks['open']
97
 
        for hook in hooks:
98
 
            hook(self)
99
 
 
100
 
    def _open_hook(self):
101
 
        """Called by init to allow simpler extension of the base class."""
102
 
 
103
 
    def _activate_fallback_location(self, url):
104
 
        """Activate the branch/repository from url as a fallback repository."""
105
 
        repo = self._get_fallback_repository(url)
106
 
        if repo.has_same_location(self.repository):
107
 
            raise errors.UnstackableLocationError(self.user_url, url)
108
 
        self.repository.add_fallback_repository(repo)
109
103
 
110
104
    def break_lock(self):
111
105
        """Break a lock if one is present from another instance.
121
115
        if master is not None:
122
116
            master.break_lock()
123
117
 
124
 
    def _check_stackable_repo(self):
125
 
        if not self.repository._format.supports_external_lookups:
126
 
            raise errors.UnstackableRepositoryFormat(self.repository._format,
127
 
                self.repository.base)
128
 
 
129
 
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
130
 
        """Extend the partial history to include a given index
131
 
 
132
 
        If a stop_index is supplied, stop when that index has been reached.
133
 
        If a stop_revision is supplied, stop when that revision is
134
 
        encountered.  Otherwise, stop when the beginning of history is
135
 
        reached.
136
 
 
137
 
        :param stop_index: The index which should be present.  When it is
138
 
            present, history extension will stop.
139
 
        :param stop_revision: The revision id which should be present.  When
140
 
            it is encountered, history extension will stop.
141
 
        """
142
 
        if len(self._partial_revision_history_cache) == 0:
143
 
            self._partial_revision_history_cache = [self.last_revision()]
144
 
        repository._iter_for_revno(
145
 
            self.repository, self._partial_revision_history_cache,
146
 
            stop_index=stop_index, stop_revision=stop_revision)
147
 
        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
148
 
            self._partial_revision_history_cache.pop()
149
 
 
150
 
    def _get_check_refs(self):
151
 
        """Get the references needed for check().
152
 
 
153
 
        See bzrlib.check.
154
 
        """
155
 
        revid = self.last_revision()
156
 
        return [('revision-existence', revid), ('lefthand-distance', revid)]
157
 
 
158
 
    @staticmethod
159
 
    def open(base, _unsupported=False, possible_transports=None):
 
118
    @staticmethod
 
119
    @deprecated_method(zero_eight)
 
120
    def open_downlevel(base):
 
121
        """Open a branch which may be of an old format."""
 
122
        return Branch.open(base, _unsupported=True)
 
123
        
 
124
    @staticmethod
 
125
    def open(base, _unsupported=False):
160
126
        """Open the branch rooted at base.
161
127
 
162
128
        For instance, if the branch is at URL/.bzr/branch,
163
129
        Branch.open(URL) -> a Branch instance.
164
130
        """
165
 
        control = bzrdir.BzrDir.open(base, _unsupported,
166
 
                                     possible_transports=possible_transports)
167
 
        return control.open_branch(unsupported=_unsupported)
168
 
 
169
 
    @staticmethod
170
 
    def open_from_transport(transport, name=None, _unsupported=False):
171
 
        """Open the branch rooted at transport"""
172
 
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
173
 
        return control.open_branch(name=name, unsupported=_unsupported)
174
 
 
175
 
    @staticmethod
176
 
    def open_containing(url, possible_transports=None):
 
131
        control = bzrdir.BzrDir.open(base, _unsupported)
 
132
        return control.open_branch(_unsupported)
 
133
 
 
134
    @staticmethod
 
135
    def open_containing(url):
177
136
        """Open an existing branch which contains url.
178
 
 
 
137
        
179
138
        This probes for a branch at url, and searches upwards from there.
180
139
 
181
140
        Basically we keep looking up until we find the control directory or
182
141
        run into the root.  If there isn't one, raises NotBranchError.
183
 
        If there is one and it is either an unrecognised format or an unsupported
 
142
        If there is one and it is either an unrecognised format or an unsupported 
184
143
        format, UnknownFormatError or UnsupportedFormatError are raised.
185
144
        If there is one, it is returned, along with the unused portion of url.
186
145
        """
187
 
        control, relpath = bzrdir.BzrDir.open_containing(url,
188
 
                                                         possible_transports)
 
146
        control, relpath = bzrdir.BzrDir.open_containing(url)
189
147
        return control.open_branch(), relpath
190
148
 
191
 
    def _push_should_merge_tags(self):
192
 
        """Should _basic_push merge this branch's tags into the target?
193
 
 
194
 
        The default implementation returns False if this branch has no tags,
195
 
        and True the rest of the time.  Subclasses may override this.
196
 
        """
197
 
        return self.supports_tags() and self.tags.get_tag_dict()
 
149
    @staticmethod
 
150
    @deprecated_function(zero_eight)
 
151
    def initialize(base):
 
152
        """Create a new working tree and branch, rooted at 'base' (url)
 
153
 
 
154
        NOTE: This will soon be deprecated in favour of creation
 
155
        through a BzrDir.
 
156
        """
 
157
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
 
158
 
 
159
    @deprecated_function(zero_eight)
 
160
    def setup_caching(self, cache_root):
 
161
        """Subclasses that care about caching should override this, and set
 
162
        up cached stores located under cache_root.
 
163
        
 
164
        NOTE: This is unused.
 
165
        """
 
166
        pass
198
167
 
199
168
    def get_config(self):
200
169
        return BranchConfig(self)
201
170
 
202
 
    def _get_config(self):
203
 
        """Get the concrete config for just the config in this branch.
204
 
 
205
 
        This is not intended for client use; see Branch.get_config for the
206
 
        public API.
207
 
 
208
 
        Added in 1.14.
209
 
 
210
 
        :return: An object supporting get_option and set_option.
211
 
        """
212
 
        raise NotImplementedError(self._get_config)
213
 
 
214
 
    def _get_fallback_repository(self, url):
215
 
        """Get the repository we fallback to at url."""
216
 
        url = urlutils.join(self.base, url)
217
 
        a_branch = Branch.open(url,
218
 
            possible_transports=[self.bzrdir.root_transport])
219
 
        return a_branch.repository
220
 
 
221
 
    def _get_tags_bytes(self):
222
 
        """Get the bytes of a serialised tags dict.
223
 
 
224
 
        Note that not all branches support tags, nor do all use the same tags
225
 
        logic: this method is specific to BasicTags. Other tag implementations
226
 
        may use the same method name and behave differently, safely, because
227
 
        of the double-dispatch via
228
 
        format.make_tags->tags_instance->get_tags_dict.
229
 
 
230
 
        :return: The bytes of the tags file.
231
 
        :seealso: Branch._set_tags_bytes.
232
 
        """
233
 
        return self._transport.get_bytes('tags')
234
 
 
235
 
    def _get_nick(self, local=False, possible_transports=None):
236
 
        config = self.get_config()
237
 
        # explicit overrides master, but don't look for master if local is True
238
 
        if not local and not config.has_explicit_nickname():
239
 
            try:
240
 
                master = self.get_master_branch(possible_transports)
241
 
                if master is not None:
242
 
                    # return the master branch value
243
 
                    return master.nick
244
 
            except errors.BzrError, e:
245
 
                # Silently fall back to local implicit nick if the master is
246
 
                # unavailable
247
 
                mutter("Could not connect to bound branch, "
248
 
                    "falling back to local nick.\n " + str(e))
249
 
        return config.get_nickname()
 
171
    def _get_nick(self):
 
172
        return self.get_config().get_nickname()
250
173
 
251
174
    def _set_nick(self, nick):
252
 
        self.get_config().set_user_option('nickname', nick, warn_masked=True)
 
175
        self.get_config().set_user_option('nickname', nick)
253
176
 
254
177
    nick = property(_get_nick, _set_nick)
255
178
 
256
179
    def is_locked(self):
257
180
        raise NotImplementedError(self.is_locked)
258
181
 
259
 
    def _lefthand_history(self, revision_id, last_rev=None,
260
 
                          other_branch=None):
261
 
        if 'evil' in debug.debug_flags:
262
 
            mutter_callsite(4, "_lefthand_history scales with history.")
263
 
        # stop_revision must be a descendant of last_revision
264
 
        graph = self.repository.get_graph()
265
 
        if last_rev is not None:
266
 
            if not graph.is_ancestor(last_rev, revision_id):
267
 
                # our previous tip is not merged into stop_revision
268
 
                raise errors.DivergedBranches(self, other_branch)
269
 
        # make a new revision history from the graph
270
 
        parents_map = graph.get_parent_map([revision_id])
271
 
        if revision_id not in parents_map:
272
 
            raise errors.NoSuchRevision(self, revision_id)
273
 
        current_rev_id = revision_id
274
 
        new_history = []
275
 
        check_not_reserved_id = _mod_revision.check_not_reserved_id
276
 
        # Do not include ghosts or graph origin in revision_history
277
 
        while (current_rev_id in parents_map and
278
 
               len(parents_map[current_rev_id]) > 0):
279
 
            check_not_reserved_id(current_rev_id)
280
 
            new_history.append(current_rev_id)
281
 
            current_rev_id = parents_map[current_rev_id][0]
282
 
            parents_map = graph.get_parent_map([current_rev_id])
283
 
        new_history.reverse()
284
 
        return new_history
285
 
 
286
 
    def lock_write(self, token=None):
287
 
        """Lock the branch for write operations.
288
 
 
289
 
        :param token: A token to permit reacquiring a previously held and
290
 
            preserved lock.
291
 
        :return: A BranchWriteLockResult.
292
 
        """
 
182
    def lock_write(self):
293
183
        raise NotImplementedError(self.lock_write)
294
184
 
295
185
    def lock_read(self):
296
 
        """Lock the branch for read operations.
297
 
 
298
 
        :return: A bzrlib.lock.LogicalLockResult.
299
 
        """
300
186
        raise NotImplementedError(self.lock_read)
301
187
 
302
188
    def unlock(self):
309
195
    def get_physical_lock_status(self):
310
196
        raise NotImplementedError(self.get_physical_lock_status)
311
197
 
312
 
    @needs_read_lock
313
 
    def dotted_revno_to_revision_id(self, revno, _cache_reverse=False):
314
 
        """Return the revision_id for a dotted revno.
315
 
 
316
 
        :param revno: a tuple like (1,) or (1,1,2)
317
 
        :param _cache_reverse: a private parameter enabling storage
318
 
           of the reverse mapping in a top level cache. (This should
319
 
           only be done in selective circumstances as we want to
320
 
           avoid having the mapping cached multiple times.)
321
 
        :return: the revision_id
322
 
        :raises errors.NoSuchRevision: if the revno doesn't exist
323
 
        """
324
 
        rev_id = self._do_dotted_revno_to_revision_id(revno)
325
 
        if _cache_reverse:
326
 
            self._partial_revision_id_to_revno_cache[rev_id] = revno
327
 
        return rev_id
328
 
 
329
 
    def _do_dotted_revno_to_revision_id(self, revno):
330
 
        """Worker function for dotted_revno_to_revision_id.
331
 
 
332
 
        Subclasses should override this if they wish to
333
 
        provide a more efficient implementation.
334
 
        """
335
 
        if len(revno) == 1:
336
 
            return self.get_rev_id(revno[0])
337
 
        revision_id_to_revno = self.get_revision_id_to_revno_map()
338
 
        revision_ids = [revision_id for revision_id, this_revno
339
 
                        in revision_id_to_revno.iteritems()
340
 
                        if revno == this_revno]
341
 
        if len(revision_ids) == 1:
342
 
            return revision_ids[0]
343
 
        else:
344
 
            revno_str = '.'.join(map(str, revno))
345
 
            raise errors.NoSuchRevision(self, revno_str)
346
 
 
347
 
    @needs_read_lock
348
 
    def revision_id_to_dotted_revno(self, revision_id):
349
 
        """Given a revision id, return its dotted revno.
350
 
 
351
 
        :return: a tuple like (1,) or (400,1,3).
352
 
        """
353
 
        return self._do_revision_id_to_dotted_revno(revision_id)
354
 
 
355
 
    def _do_revision_id_to_dotted_revno(self, revision_id):
356
 
        """Worker function for revision_id_to_revno."""
357
 
        # Try the caches if they are loaded
358
 
        result = self._partial_revision_id_to_revno_cache.get(revision_id)
359
 
        if result is not None:
360
 
            return result
361
 
        if self._revision_id_to_revno_cache:
362
 
            result = self._revision_id_to_revno_cache.get(revision_id)
363
 
            if result is None:
364
 
                raise errors.NoSuchRevision(self, revision_id)
365
 
        # Try the mainline as it's optimised
366
 
        try:
367
 
            revno = self.revision_id_to_revno(revision_id)
368
 
            return (revno,)
369
 
        except errors.NoSuchRevision:
370
 
            # We need to load and use the full revno map after all
371
 
            result = self.get_revision_id_to_revno_map().get(revision_id)
372
 
            if result is None:
373
 
                raise errors.NoSuchRevision(self, revision_id)
374
 
        return result
375
 
 
376
 
    @needs_read_lock
377
 
    def get_revision_id_to_revno_map(self):
378
 
        """Return the revision_id => dotted revno map.
379
 
 
380
 
        This will be regenerated on demand, but will be cached.
381
 
 
382
 
        :return: A dictionary mapping revision_id => dotted revno.
383
 
            This dictionary should not be modified by the caller.
384
 
        """
385
 
        if self._revision_id_to_revno_cache is not None:
386
 
            mapping = self._revision_id_to_revno_cache
387
 
        else:
388
 
            mapping = self._gen_revno_map()
389
 
            self._cache_revision_id_to_revno(mapping)
390
 
        # TODO: jam 20070417 Since this is being cached, should we be returning
391
 
        #       a copy?
392
 
        # I would rather not, and instead just declare that users should not
393
 
        # modify the return value.
394
 
        return mapping
395
 
 
396
 
    def _gen_revno_map(self):
397
 
        """Create a new mapping from revision ids to dotted revnos.
398
 
 
399
 
        Dotted revnos are generated based on the current tip in the revision
400
 
        history.
401
 
        This is the worker function for get_revision_id_to_revno_map, which
402
 
        just caches the return value.
403
 
 
404
 
        :return: A dictionary mapping revision_id => dotted revno.
405
 
        """
406
 
        revision_id_to_revno = dict((rev_id, revno)
407
 
            for rev_id, depth, revno, end_of_merge
408
 
             in self.iter_merge_sorted_revisions())
409
 
        return revision_id_to_revno
410
 
 
411
 
    @needs_read_lock
412
 
    def iter_merge_sorted_revisions(self, start_revision_id=None,
413
 
            stop_revision_id=None, stop_rule='exclude', direction='reverse'):
414
 
        """Walk the revisions for a branch in merge sorted order.
415
 
 
416
 
        Merge sorted order is the output from a merge-aware,
417
 
        topological sort, i.e. all parents come before their
418
 
        children going forward; the opposite for reverse.
419
 
 
420
 
        :param start_revision_id: the revision_id to begin walking from.
421
 
            If None, the branch tip is used.
422
 
        :param stop_revision_id: the revision_id to terminate the walk
423
 
            after. If None, the rest of history is included.
424
 
        :param stop_rule: if stop_revision_id is not None, the precise rule
425
 
            to use for termination:
426
 
            * 'exclude' - leave the stop revision out of the result (default)
427
 
            * 'include' - the stop revision is the last item in the result
428
 
            * 'with-merges' - include the stop revision and all of its
429
 
              merged revisions in the result
430
 
            * 'with-merges-without-common-ancestry' - filter out revisions 
431
 
              that are in both ancestries
432
 
        :param direction: either 'reverse' or 'forward':
433
 
            * reverse means return the start_revision_id first, i.e.
434
 
              start at the most recent revision and go backwards in history
435
 
            * forward returns tuples in the opposite order to reverse.
436
 
              Note in particular that forward does *not* do any intelligent
437
 
              ordering w.r.t. depth as some clients of this API may like.
438
 
              (If required, that ought to be done at higher layers.)
439
 
 
440
 
        :return: an iterator over (revision_id, depth, revno, end_of_merge)
441
 
            tuples where:
442
 
 
443
 
            * revision_id: the unique id of the revision
444
 
            * depth: How many levels of merging deep this node has been
445
 
              found.
446
 
            * revno_sequence: This field provides a sequence of
447
 
              revision numbers for all revisions. The format is:
448
 
              (REVNO, BRANCHNUM, BRANCHREVNO). BRANCHNUM is the number of the
449
 
              branch that the revno is on. From left to right the REVNO numbers
450
 
              are the sequence numbers within that branch of the revision.
451
 
            * end_of_merge: When True the next node (earlier in history) is
452
 
              part of a different merge.
453
 
        """
454
 
        # Note: depth and revno values are in the context of the branch so
455
 
        # we need the full graph to get stable numbers, regardless of the
456
 
        # start_revision_id.
457
 
        if self._merge_sorted_revisions_cache is None:
458
 
            last_revision = self.last_revision()
459
 
            known_graph = self.repository.get_known_graph_ancestry(
460
 
                [last_revision])
461
 
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
462
 
                last_revision)
463
 
        filtered = self._filter_merge_sorted_revisions(
464
 
            self._merge_sorted_revisions_cache, start_revision_id,
465
 
            stop_revision_id, stop_rule)
466
 
        # Make sure we don't return revisions that are not part of the
467
 
        # start_revision_id ancestry.
468
 
        filtered = self._filter_start_non_ancestors(filtered)
469
 
        if direction == 'reverse':
470
 
            return filtered
471
 
        if direction == 'forward':
472
 
            return reversed(list(filtered))
473
 
        else:
474
 
            raise ValueError('invalid direction %r' % direction)
475
 
 
476
 
    def _filter_merge_sorted_revisions(self, merge_sorted_revisions,
477
 
        start_revision_id, stop_revision_id, stop_rule):
478
 
        """Iterate over an inclusive range of sorted revisions."""
479
 
        rev_iter = iter(merge_sorted_revisions)
480
 
        if start_revision_id is not None:
481
 
            for node in rev_iter:
482
 
                rev_id = node.key[-1]
483
 
                if rev_id != start_revision_id:
484
 
                    continue
485
 
                else:
486
 
                    # The decision to include the start or not
487
 
                    # depends on the stop_rule if a stop is provided
488
 
                    # so pop this node back into the iterator
489
 
                    rev_iter = chain(iter([node]), rev_iter)
490
 
                    break
491
 
        if stop_revision_id is None:
492
 
            # Yield everything
493
 
            for node in rev_iter:
494
 
                rev_id = node.key[-1]
495
 
                yield (rev_id, node.merge_depth, node.revno,
496
 
                       node.end_of_merge)
497
 
        elif stop_rule == 'exclude':
498
 
            for node in rev_iter:
499
 
                rev_id = node.key[-1]
500
 
                if rev_id == stop_revision_id:
501
 
                    return
502
 
                yield (rev_id, node.merge_depth, node.revno,
503
 
                       node.end_of_merge)
504
 
        elif stop_rule == 'include':
505
 
            for node in rev_iter:
506
 
                rev_id = node.key[-1]
507
 
                yield (rev_id, node.merge_depth, node.revno,
508
 
                       node.end_of_merge)
509
 
                if rev_id == stop_revision_id:
510
 
                    return
511
 
        elif stop_rule == 'with-merges-without-common-ancestry':
512
 
            # We want to exclude all revisions that are already part of the
513
 
            # stop_revision_id ancestry.
514
 
            graph = self.repository.get_graph()
515
 
            ancestors = graph.find_unique_ancestors(start_revision_id,
516
 
                                                    [stop_revision_id])
517
 
            for node in rev_iter:
518
 
                rev_id = node.key[-1]
519
 
                if rev_id not in ancestors:
520
 
                    continue
521
 
                yield (rev_id, node.merge_depth, node.revno,
522
 
                       node.end_of_merge)
523
 
        elif stop_rule == 'with-merges':
524
 
            stop_rev = self.repository.get_revision(stop_revision_id)
525
 
            if stop_rev.parent_ids:
526
 
                left_parent = stop_rev.parent_ids[0]
527
 
            else:
528
 
                left_parent = _mod_revision.NULL_REVISION
529
 
            # left_parent is the actual revision we want to stop logging at,
530
 
            # since we want to show the merged revisions after the stop_rev too
531
 
            reached_stop_revision_id = False
532
 
            revision_id_whitelist = []
533
 
            for node in rev_iter:
534
 
                rev_id = node.key[-1]
535
 
                if rev_id == left_parent:
536
 
                    # reached the left parent after the stop_revision
537
 
                    return
538
 
                if (not reached_stop_revision_id or
539
 
                        rev_id in revision_id_whitelist):
540
 
                    yield (rev_id, node.merge_depth, node.revno,
541
 
                       node.end_of_merge)
542
 
                    if reached_stop_revision_id or rev_id == stop_revision_id:
543
 
                        # only do the merged revs of rev_id from now on
544
 
                        rev = self.repository.get_revision(rev_id)
545
 
                        if rev.parent_ids:
546
 
                            reached_stop_revision_id = True
547
 
                            revision_id_whitelist.extend(rev.parent_ids)
548
 
        else:
549
 
            raise ValueError('invalid stop_rule %r' % stop_rule)
550
 
 
551
 
    def _filter_start_non_ancestors(self, rev_iter):
552
 
        # If we started from a dotted revno, we want to consider it as a tip
553
 
        # and don't want to yield revisions that are not part of its
554
 
        # ancestry. Given the order guaranteed by the merge sort, we will see
555
 
        # uninteresting descendants of the first parent of our tip before the
556
 
        # tip itself.
557
 
        first = rev_iter.next()
558
 
        (rev_id, merge_depth, revno, end_of_merge) = first
559
 
        yield first
560
 
        if not merge_depth:
561
 
            # We start at a mainline revision so by definition, all others
562
 
            # revisions in rev_iter are ancestors
563
 
            for node in rev_iter:
564
 
                yield node
565
 
 
566
 
        clean = False
567
 
        whitelist = set()
568
 
        pmap = self.repository.get_parent_map([rev_id])
569
 
        parents = pmap.get(rev_id, [])
570
 
        if parents:
571
 
            whitelist.update(parents)
572
 
        else:
573
 
            # If there is no parents, there is nothing of interest left
574
 
 
575
 
            # FIXME: It's hard to test this scenario here as this code is never
576
 
            # called in that case. -- vila 20100322
577
 
            return
578
 
 
579
 
        for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
580
 
            if not clean:
581
 
                if rev_id in whitelist:
582
 
                    pmap = self.repository.get_parent_map([rev_id])
583
 
                    parents = pmap.get(rev_id, [])
584
 
                    whitelist.remove(rev_id)
585
 
                    whitelist.update(parents)
586
 
                    if merge_depth == 0:
587
 
                        # We've reached the mainline, there is nothing left to
588
 
                        # filter
589
 
                        clean = True
590
 
                else:
591
 
                    # A revision that is not part of the ancestry of our
592
 
                    # starting revision.
593
 
                    continue
594
 
            yield (rev_id, merge_depth, revno, end_of_merge)
595
 
 
596
198
    def leave_lock_in_place(self):
597
199
        """Tell this branch object not to release the physical lock when this
598
200
        object is unlocked.
599
 
 
 
201
        
600
202
        If lock_write doesn't return a token, then this method is not supported.
601
203
        """
602
204
        self.control_files.leave_in_place()
609
211
        """
610
212
        self.control_files.dont_leave_in_place()
611
213
 
 
214
    def abspath(self, name):
 
215
        """Return absolute filename for something in the branch
 
216
        
 
217
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
218
        method and not a tree method.
 
219
        """
 
220
        raise NotImplementedError(self.abspath)
 
221
 
612
222
    def bind(self, other):
613
223
        """Bind the local branch the other branch.
614
224
 
615
225
        :param other: The branch to bind to
616
226
        :type other: Branch
617
227
        """
618
 
        raise errors.UpgradeRequired(self.user_url)
619
 
 
620
 
    def set_append_revisions_only(self, enabled):
621
 
        if not self._format.supports_set_append_revisions_only():
622
 
            raise errors.UpgradeRequired(self.user_url)
623
 
        if enabled:
624
 
            value = 'True'
625
 
        else:
626
 
            value = 'False'
627
 
        self.get_config().set_user_option('append_revisions_only', value,
628
 
            warn_masked=True)
629
 
 
630
 
    def set_reference_info(self, file_id, tree_path, branch_location):
631
 
        """Set the branch location to use for a tree reference."""
632
 
        raise errors.UnsupportedOperation(self.set_reference_info, self)
633
 
 
634
 
    def get_reference_info(self, file_id):
635
 
        """Get the tree_path and branch_location for a tree reference."""
636
 
        raise errors.UnsupportedOperation(self.get_reference_info, self)
 
228
        raise errors.UpgradeRequired(self.base)
637
229
 
638
230
    @needs_write_lock
639
231
    def fetch(self, from_branch, last_revision=None, pb=None):
643
235
        :param last_revision: What revision to stop at (None for at the end
644
236
                              of the branch.
645
237
        :param pb: An optional progress bar to use.
646
 
        :return: None
 
238
 
 
239
        Returns the copied revision count and the failed revisions in a tuple:
 
240
        (copied, failures).
647
241
        """
648
242
        if self.base == from_branch.base:
649
243
            return (0, [])
650
 
        if pb is not None:
651
 
            symbol_versioning.warn(
652
 
                symbol_versioning.deprecated_in((1, 14, 0))
653
 
                % "pb parameter to fetch()")
 
244
        if pb is None:
 
245
            nested_pb = ui.ui_factory.nested_progress_bar()
 
246
            pb = nested_pb
 
247
        else:
 
248
            nested_pb = None
 
249
 
654
250
        from_branch.lock_read()
655
251
        try:
656
252
            if last_revision is None:
 
253
                pb.update('get source history')
657
254
                last_revision = from_branch.last_revision()
658
 
                last_revision = _mod_revision.ensure_null(last_revision)
 
255
                if last_revision is None:
 
256
                    last_revision = _mod_revision.NULL_REVISION
659
257
            return self.repository.fetch(from_branch.repository,
660
258
                                         revision_id=last_revision,
661
 
                                         pb=pb)
 
259
                                         pb=nested_pb)
662
260
        finally:
 
261
            if nested_pb is not None:
 
262
                nested_pb.finished()
663
263
            from_branch.unlock()
664
264
 
665
265
    def get_bound_location(self):
669
269
        branch.
670
270
        """
671
271
        return None
672
 
 
 
272
    
673
273
    def get_old_bound_location(self):
674
274
        """Return the URL of the branch we used to be bound to
675
275
        """
676
 
        raise errors.UpgradeRequired(self.user_url)
 
276
        raise errors.UpgradeRequired(self.base)
677
277
 
678
 
    def get_commit_builder(self, parents, config=None, timestamp=None,
679
 
                           timezone=None, committer=None, revprops=None,
 
278
    def get_commit_builder(self, parents, config=None, timestamp=None, 
 
279
                           timezone=None, committer=None, revprops=None, 
680
280
                           revision_id=None):
681
281
        """Obtain a CommitBuilder for this branch.
682
 
 
 
282
        
683
283
        :param parents: Revision ids of the parents of the new revision.
684
284
        :param config: Optional configuration to use.
685
285
        :param timestamp: Optional timestamp recorded for commit.
691
291
 
692
292
        if config is None:
693
293
            config = self.get_config()
694
 
 
 
294
        
695
295
        return self.repository.get_commit_builder(self, parents, config,
696
296
            timestamp, timezone, committer, revprops, revision_id)
697
297
 
698
 
    def get_master_branch(self, possible_transports=None):
 
298
    def get_master_branch(self):
699
299
        """Return the branch we are bound to.
700
 
 
 
300
        
701
301
        :return: Either a Branch, or None
702
302
        """
703
303
        return None
708
308
        The delta is relative to its mainline predecessor, or the
709
309
        empty tree for revision 1.
710
310
        """
 
311
        assert isinstance(revno, int)
711
312
        rh = self.revision_history()
712
313
        if not (1 <= revno <= len(rh)):
713
 
            raise errors.InvalidRevisionNumber(revno)
 
314
            raise InvalidRevisionNumber(revno)
714
315
        return self.repository.get_revision_delta(rh[revno-1])
715
316
 
716
 
    def get_stacked_on_url(self):
717
 
        """Get the URL this branch is stacked against.
 
317
    @deprecated_method(zero_sixteen)
 
318
    def get_root_id(self):
 
319
        """Return the id of this branches root
718
320
 
719
 
        :raises NotStacked: If the branch is not stacked.
720
 
        :raises UnstackableBranchFormat: If the branch does not support
721
 
            stacking.
 
321
        Deprecated: branches don't have root ids-- trees do.
 
322
        Use basis_tree().get_root_id() instead.
722
323
        """
723
 
        raise NotImplementedError(self.get_stacked_on_url)
 
324
        raise NotImplementedError(self.get_root_id)
724
325
 
725
326
    def print_file(self, file, revision_id):
726
327
        """Print `file` to stdout."""
727
328
        raise NotImplementedError(self.print_file)
728
329
 
 
330
    def append_revision(self, *revision_ids):
 
331
        raise NotImplementedError(self.append_revision)
 
332
 
729
333
    def set_revision_history(self, rev_history):
730
334
        raise NotImplementedError(self.set_revision_history)
731
335
 
732
 
    @needs_write_lock
733
 
    def set_parent(self, url):
734
 
        """See Branch.set_parent."""
735
 
        # TODO: Maybe delete old location files?
736
 
        # URLs should never be unicode, even on the local fs,
737
 
        # FIXUP this and get_parent in a future branch format bump:
738
 
        # read and rewrite the file. RBC 20060125
739
 
        if url is not None:
740
 
            if isinstance(url, unicode):
741
 
                try:
742
 
                    url = url.encode('ascii')
743
 
                except UnicodeEncodeError:
744
 
                    raise errors.InvalidURL(url,
745
 
                        "Urls must be 7-bit ascii, "
746
 
                        "use bzrlib.urlutils.escape")
747
 
            url = urlutils.relative_url(self.base, url)
748
 
        self._set_parent_location(url)
749
 
 
750
 
    @needs_write_lock
751
 
    def set_stacked_on_url(self, url):
752
 
        """Set the URL this branch is stacked against.
753
 
 
754
 
        :raises UnstackableBranchFormat: If the branch does not support
755
 
            stacking.
756
 
        :raises UnstackableRepositoryFormat: If the repository does not support
757
 
            stacking.
758
 
        """
759
 
        if not self._format.supports_stacking():
760
 
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
761
 
        # XXX: Changing from one fallback repository to another does not check
762
 
        # that all the data you need is present in the new fallback.
763
 
        # Possibly it should.
764
 
        self._check_stackable_repo()
765
 
        if not url:
766
 
            try:
767
 
                old_url = self.get_stacked_on_url()
768
 
            except (errors.NotStacked, errors.UnstackableBranchFormat,
769
 
                errors.UnstackableRepositoryFormat):
770
 
                return
771
 
            self._unstack()
772
 
        else:
773
 
            self._activate_fallback_location(url)
774
 
        # write this out after the repository is stacked to avoid setting a
775
 
        # stacked config that doesn't work.
776
 
        self._set_config_location('stacked_on_location', url)
777
 
 
778
 
    def _unstack(self):
779
 
        """Change a branch to be unstacked, copying data as needed.
780
 
        
781
 
        Don't call this directly, use set_stacked_on_url(None).
782
 
        """
783
 
        pb = ui.ui_factory.nested_progress_bar()
784
 
        try:
785
 
            pb.update("Unstacking")
786
 
            # The basic approach here is to fetch the tip of the branch,
787
 
            # including all available ghosts, from the existing stacked
788
 
            # repository into a new repository object without the fallbacks. 
789
 
            #
790
 
            # XXX: See <https://launchpad.net/bugs/397286> - this may not be
791
 
            # correct for CHKMap repostiories
792
 
            old_repository = self.repository
793
 
            if len(old_repository._fallback_repositories) != 1:
794
 
                raise AssertionError("can't cope with fallback repositories "
795
 
                    "of %r" % (self.repository,))
796
 
            # unlock it, including unlocking the fallback
797
 
            old_repository.unlock()
798
 
            old_repository.lock_read()
799
 
            try:
800
 
                # Repositories don't offer an interface to remove fallback
801
 
                # repositories today; take the conceptually simpler option and just
802
 
                # reopen it.  We reopen it starting from the URL so that we
803
 
                # get a separate connection for RemoteRepositories and can
804
 
                # stream from one of them to the other.  This does mean doing
805
 
                # separate SSH connection setup, but unstacking is not a
806
 
                # common operation so it's tolerable.
807
 
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
808
 
                new_repository = new_bzrdir.find_repository()
809
 
                self.repository = new_repository
810
 
                if self.repository._fallback_repositories:
811
 
                    raise AssertionError("didn't expect %r to have "
812
 
                        "fallback_repositories"
813
 
                        % (self.repository,))
814
 
                # this is not paired with an unlock because it's just restoring
815
 
                # the previous state; the lock's released when set_stacked_on_url
816
 
                # returns
817
 
                self.repository.lock_write()
818
 
                # XXX: If you unstack a branch while it has a working tree
819
 
                # with a pending merge, the pending-merged revisions will no
820
 
                # longer be present.  You can (probably) revert and remerge.
821
 
                #
822
 
                # XXX: This only fetches up to the tip of the repository; it
823
 
                # doesn't bring across any tags.  That's fairly consistent
824
 
                # with how branch works, but perhaps not ideal.
825
 
                self.repository.fetch(old_repository,
826
 
                    revision_id=self.last_revision(),
827
 
                    find_ghosts=True)
828
 
            finally:
829
 
                old_repository.unlock()
830
 
        finally:
831
 
            pb.finished()
832
 
 
833
 
    def _set_tags_bytes(self, bytes):
834
 
        """Mirror method for _get_tags_bytes.
835
 
 
836
 
        :seealso: Branch._get_tags_bytes.
837
 
        """
838
 
        return _run_with_write_locked_target(self, self._transport.put_bytes,
839
 
            'tags', bytes)
840
 
 
841
336
    def _cache_revision_history(self, rev_history):
842
337
        """Set the cached revision history to rev_history.
843
338
 
849
344
        """
850
345
        self._revision_history_cache = rev_history
851
346
 
852
 
    def _cache_revision_id_to_revno(self, revision_id_to_revno):
853
 
        """Set the cached revision_id => revno map to revision_id_to_revno.
854
 
 
855
 
        This API is semi-public; it only for use by subclasses, all other code
856
 
        should consider it to be private.
857
 
        """
858
 
        self._revision_id_to_revno_cache = revision_id_to_revno
859
 
 
860
347
    def _clear_cached_state(self):
861
348
        """Clear any cached data on this branch, e.g. cached revision history.
862
349
 
867
354
        should consider it to be private.
868
355
        """
869
356
        self._revision_history_cache = None
870
 
        self._revision_id_to_revno_cache = None
871
 
        self._last_revision_info_cache = None
872
 
        self._merge_sorted_revisions_cache = None
873
 
        self._partial_revision_history_cache = []
874
 
        self._partial_revision_id_to_revno_cache = {}
875
357
 
876
358
    def _gen_revision_history(self):
877
359
        """Return sequence of revision hashes on to this branch.
878
 
 
 
360
        
879
361
        Unlike revision_history, this method always regenerates or rereads the
880
362
        revision history, i.e. it does not cache the result, so repeated calls
881
363
        may be expensive.
882
364
 
883
365
        Concrete subclasses should override this instead of revision_history so
884
366
        that subclasses do not need to deal with caching logic.
885
 
 
 
367
        
886
368
        This API is semi-public; it only for use by subclasses, all other code
887
369
        should consider it to be private.
888
370
        """
890
372
 
891
373
    @needs_read_lock
892
374
    def revision_history(self):
893
 
        """Return sequence of revision ids on this branch.
894
 
 
 
375
        """Return sequence of revision hashes on to this branch.
 
376
        
895
377
        This method will cache the revision history for as long as it is safe to
896
378
        do so.
897
379
        """
898
 
        if 'evil' in debug.debug_flags:
899
 
            mutter_callsite(3, "revision_history scales with history.")
900
380
        if self._revision_history_cache is not None:
901
381
            history = self._revision_history_cache
902
382
        else:
910
390
        That is equivalent to the number of revisions committed to
911
391
        this branch.
912
392
        """
913
 
        return self.last_revision_info()[0]
 
393
        return len(self.revision_history())
914
394
 
915
395
    def unbind(self):
916
396
        """Older format branches cannot bind or unbind."""
917
 
        raise errors.UpgradeRequired(self.user_url)
 
397
        raise errors.UpgradeRequired(self.base)
 
398
 
 
399
    def set_append_revisions_only(self, enabled):
 
400
        """Older format branches are never restricted to append-only"""
 
401
        raise errors.UpgradeRequired(self.base)
918
402
 
919
403
    def last_revision(self):
920
 
        """Return last revision id, or NULL_REVISION."""
921
 
        return self.last_revision_info()[1]
 
404
        """Return last revision id, or None"""
 
405
        ph = self.revision_history()
 
406
        if ph:
 
407
            return ph[-1]
 
408
        else:
 
409
            return None
922
410
 
923
 
    @needs_read_lock
924
411
    def last_revision_info(self):
925
412
        """Return information about the last revision.
926
413
 
927
 
        :return: A tuple (revno, revision_id).
 
414
        :return: A tuple (revno, last_revision_id).
928
415
        """
929
 
        if self._last_revision_info_cache is None:
930
 
            self._last_revision_info_cache = self._last_revision_info()
931
 
        return self._last_revision_info_cache
932
 
 
933
 
    def _last_revision_info(self):
934
416
        rh = self.revision_history()
935
417
        revno = len(rh)
936
418
        if revno:
938
420
        else:
939
421
            return (0, _mod_revision.NULL_REVISION)
940
422
 
941
 
    @deprecated_method(deprecated_in((1, 6, 0)))
942
423
    def missing_revisions(self, other, stop_revision=None):
943
424
        """Return a list of new revisions that would perfectly fit.
944
 
 
 
425
        
945
426
        If self and other have not diverged, return a list of the revisions
946
427
        present in other, but missing from self.
947
428
        """
952
433
        common_index = min(self_len, other_len) -1
953
434
        if common_index >= 0 and \
954
435
            self_history[common_index] != other_history[common_index]:
955
 
            raise errors.DivergedBranches(self, other)
 
436
            raise DivergedBranches(self, other)
956
437
 
957
438
        if stop_revision is None:
958
439
            stop_revision = other_len
959
440
        else:
 
441
            assert isinstance(stop_revision, int)
960
442
            if stop_revision > other_len:
961
443
                raise errors.NoSuchRevision(self, stop_revision)
962
444
        return other_history[self_len:stop_revision]
963
445
 
964
 
    @needs_write_lock
965
 
    def update_revisions(self, other, stop_revision=None, overwrite=False,
966
 
                         graph=None):
 
446
    def update_revisions(self, other, stop_revision=None):
967
447
        """Pull in new perfect-fit revisions.
968
448
 
969
449
        :param other: Another Branch to pull from
970
450
        :param stop_revision: Updated until the given revision
971
 
        :param overwrite: Always set the branch pointer, rather than checking
972
 
            to see if it is a proper descendant.
973
 
        :param graph: A Graph object that can be used to query history
974
 
            information. This can be None.
975
451
        :return: None
976
452
        """
977
 
        return InterBranch.get(other, self).update_revisions(stop_revision,
978
 
            overwrite, graph)
979
 
 
980
 
    def import_last_revision_info(self, source_repo, revno, revid):
981
 
        """Set the last revision info, importing from another repo if necessary.
982
 
 
983
 
        This is used by the bound branch code to upload a revision to
984
 
        the master branch first before updating the tip of the local branch.
985
 
 
986
 
        :param source_repo: Source repository to optionally fetch from
987
 
        :param revno: Revision number of the new tip
988
 
        :param revid: Revision id of the new tip
989
 
        """
990
 
        if not self.repository.has_same_location(source_repo):
991
 
            self.repository.fetch(source_repo, revision_id=revid)
992
 
        self.set_last_revision_info(revno, revid)
 
453
        raise NotImplementedError(self.update_revisions)
993
454
 
994
455
    def revision_id_to_revno(self, revision_id):
995
456
        """Given a revision id, return its revno"""
996
 
        if _mod_revision.is_null(revision_id):
 
457
        if revision_id is None:
997
458
            return 0
 
459
        revision_id = osutils.safe_revision_id(revision_id)
998
460
        history = self.revision_history()
999
461
        try:
1000
462
            return history.index(revision_id) + 1
1001
463
        except ValueError:
1002
 
            raise errors.NoSuchRevision(self, revision_id)
 
464
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
1003
465
 
1004
 
    @needs_read_lock
1005
466
    def get_rev_id(self, revno, history=None):
1006
467
        """Find the revision id of the specified revno."""
1007
468
        if revno == 0:
1008
 
            return _mod_revision.NULL_REVISION
1009
 
        last_revno, last_revid = self.last_revision_info()
1010
 
        if revno == last_revno:
1011
 
            return last_revid
1012
 
        if revno <= 0 or revno > last_revno:
1013
 
            raise errors.NoSuchRevision(self, revno)
1014
 
        distance_from_last = last_revno - revno
1015
 
        if len(self._partial_revision_history_cache) <= distance_from_last:
1016
 
            self._extend_partial_history(distance_from_last)
1017
 
        return self._partial_revision_history_cache[distance_from_last]
 
469
            return None
 
470
        if history is None:
 
471
            history = self.revision_history()
 
472
        if revno <= 0 or revno > len(history):
 
473
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
474
        return history[revno - 1]
1018
475
 
1019
 
    @needs_write_lock
1020
 
    def pull(self, source, overwrite=False, stop_revision=None,
1021
 
             possible_transports=None, *args, **kwargs):
 
476
    def pull(self, source, overwrite=False, stop_revision=None):
1022
477
        """Mirror source into this branch.
1023
478
 
1024
479
        This branch is considered to be 'local', having low latency.
1025
480
 
1026
481
        :returns: PullResult instance
1027
482
        """
1028
 
        return InterBranch.get(source, self).pull(overwrite=overwrite,
1029
 
            stop_revision=stop_revision,
1030
 
            possible_transports=possible_transports, *args, **kwargs)
 
483
        raise NotImplementedError(self.pull)
1031
484
 
1032
 
    def push(self, target, overwrite=False, stop_revision=None, *args,
1033
 
        **kwargs):
 
485
    def push(self, target, overwrite=False, stop_revision=None):
1034
486
        """Mirror this branch into target.
1035
487
 
1036
488
        This branch is considered to be 'local', having low latency.
1037
489
        """
1038
 
        return InterBranch.get(self, target).push(overwrite, stop_revision,
1039
 
            *args, **kwargs)
1040
 
 
1041
 
    def lossy_push(self, target, stop_revision=None):
1042
 
        """Push deltas into another branch.
1043
 
 
1044
 
        :note: This does not, like push, retain the revision ids from 
1045
 
            the source branch and will, rather than adding bzr-specific 
1046
 
            metadata, push only those semantics of the revision that can be 
1047
 
            natively represented by this branch' VCS.
1048
 
 
1049
 
        :param target: Target branch
1050
 
        :param stop_revision: Revision to push, defaults to last revision.
1051
 
        :return: BranchPushResult with an extra member revidmap: 
1052
 
            A dictionary mapping revision ids from the target branch 
1053
 
            to new revision ids in the target branch, for each 
1054
 
            revision that was pushed.
1055
 
        """
1056
 
        inter = InterBranch.get(self, target)
1057
 
        lossy_push = getattr(inter, "lossy_push", None)
1058
 
        if lossy_push is None:
1059
 
            raise errors.LossyPushToSameVCS(self, target)
1060
 
        return lossy_push(stop_revision)
 
490
        raise NotImplementedError(self.push)
1061
491
 
1062
492
    def basis_tree(self):
1063
493
        """Return `Tree` object for last revision."""
1064
494
        return self.repository.revision_tree(self.last_revision())
1065
495
 
 
496
    def rename_one(self, from_rel, to_rel):
 
497
        """Rename one file.
 
498
 
 
499
        This can change the directory or the filename or both.
 
500
        """
 
501
        raise NotImplementedError(self.rename_one)
 
502
 
 
503
    def move(self, from_paths, to_name):
 
504
        """Rename files.
 
505
 
 
506
        to_name must exist as a versioned directory.
 
507
 
 
508
        If to_name exists and is a directory, the files are moved into
 
509
        it, keeping their old names.  If it is a directory, 
 
510
 
 
511
        Note that to_name is only the last component of the new name;
 
512
        this doesn't change the directory.
 
513
 
 
514
        This returns a list of (from_path, to_path) pairs for each
 
515
        entry that is moved.
 
516
        """
 
517
        raise NotImplementedError(self.move)
 
518
 
1066
519
    def get_parent(self):
1067
520
        """Return the parent location of the branch.
1068
521
 
1069
 
        This is the default location for pull/missing.  The usual
 
522
        This is the default location for push/pull/missing.  The usual
1070
523
        pattern is that the user can override it by specifying a
1071
524
        location.
1072
525
        """
1073
 
        parent = self._get_parent_location()
1074
 
        if parent is None:
1075
 
            return parent
1076
 
        # This is an old-format absolute path to a local branch
1077
 
        # turn it into a url
1078
 
        if parent.startswith('/'):
1079
 
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
1080
 
        try:
1081
 
            return urlutils.join(self.base[:-1], parent)
1082
 
        except errors.InvalidURLJoin, e:
1083
 
            raise errors.InaccessibleParent(parent, self.user_url)
1084
 
 
1085
 
    def _get_parent_location(self):
1086
 
        raise NotImplementedError(self._get_parent_location)
 
526
        raise NotImplementedError(self.get_parent)
1087
527
 
1088
528
    def _set_config_location(self, name, url, config=None,
1089
529
                             make_relative=False):
1093
533
            url = ''
1094
534
        elif make_relative:
1095
535
            url = urlutils.relative_url(self.base, url)
1096
 
        config.set_user_option(name, url, warn_masked=True)
 
536
        config.set_user_option(name, url)
1097
537
 
1098
538
    def _get_config_location(self, name, config=None):
1099
539
        if config is None:
1103
543
            location = None
1104
544
        return location
1105
545
 
1106
 
    def get_child_submit_format(self):
1107
 
        """Return the preferred format of submissions to this branch."""
1108
 
        return self.get_config().get_user_option("child_submit_format")
1109
 
 
1110
546
    def get_submit_branch(self):
1111
547
        """Return the submit location of the branch.
1112
548
 
1123
559
        pattern is that the user can override it by specifying a
1124
560
        location.
1125
561
        """
1126
 
        self.get_config().set_user_option('submit_branch', location,
1127
 
            warn_masked=True)
 
562
        self.get_config().set_user_option('submit_branch', location)
1128
563
 
1129
564
    def get_public_branch(self):
1130
565
        """Return the public location of the branch.
1131
566
 
1132
 
        This is used by merge directives.
 
567
        This is is used by merge directives.
1133
568
        """
1134
569
        return self._get_config_location('public_branch')
1135
570
 
1144
579
 
1145
580
    def get_push_location(self):
1146
581
        """Return the None or the location to push this branch to."""
1147
 
        push_loc = self.get_config().get_user_option('push_location')
1148
 
        return push_loc
 
582
        raise NotImplementedError(self.get_push_location)
1149
583
 
1150
584
    def set_push_location(self, location):
1151
585
        """Set a new push location for this branch."""
1152
586
        raise NotImplementedError(self.set_push_location)
1153
587
 
1154
 
    def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
1155
 
        """Run the post_change_branch_tip hooks."""
1156
 
        hooks = Branch.hooks['post_change_branch_tip']
1157
 
        if not hooks:
1158
 
            return
1159
 
        new_revno, new_revid = self.last_revision_info()
1160
 
        params = ChangeBranchTipParams(
1161
 
            self, old_revno, new_revno, old_revid, new_revid)
1162
 
        for hook in hooks:
1163
 
            hook(params)
1164
 
 
1165
 
    def _run_pre_change_branch_tip_hooks(self, new_revno, new_revid):
1166
 
        """Run the pre_change_branch_tip hooks."""
1167
 
        hooks = Branch.hooks['pre_change_branch_tip']
1168
 
        if not hooks:
1169
 
            return
1170
 
        old_revno, old_revid = self.last_revision_info()
1171
 
        params = ChangeBranchTipParams(
1172
 
            self, old_revno, new_revno, old_revid, new_revid)
1173
 
        for hook in hooks:
1174
 
            hook(params)
 
588
    def set_parent(self, url):
 
589
        raise NotImplementedError(self.set_parent)
1175
590
 
1176
591
    @needs_write_lock
1177
592
    def update(self):
1178
 
        """Synchronise this branch with the master branch if any.
 
593
        """Synchronise this branch with the master branch if any. 
1179
594
 
1180
595
        :return: None or the last_revision pivoted out during the update.
1181
596
        """
1188
603
        """
1189
604
        if revno != 0:
1190
605
            self.check_real_revno(revno)
1191
 
 
 
606
            
1192
607
    def check_real_revno(self, revno):
1193
608
        """\
1194
609
        Check whether a revno corresponds to a real revision.
1195
610
        Zero (the NULL revision) is considered invalid
1196
611
        """
1197
612
        if revno < 1 or revno > self.revno():
1198
 
            raise errors.InvalidRevisionNumber(revno)
 
613
            raise InvalidRevisionNumber(revno)
1199
614
 
1200
615
    @needs_read_lock
1201
 
    def clone(self, to_bzrdir, revision_id=None, repository_policy=None):
 
616
    def clone(self, to_bzrdir, revision_id=None):
1202
617
        """Clone this branch into to_bzrdir preserving all semantic values.
1203
 
 
1204
 
        Most API users will want 'create_clone_on_transport', which creates a
1205
 
        new bzrdir and branch on the fly.
1206
 
 
 
618
        
1207
619
        revision_id: if not None, the revision history in the new branch will
1208
620
                     be truncated to end with revision_id.
1209
621
        """
1210
 
        result = to_bzrdir.create_branch()
1211
 
        result.lock_write()
1212
 
        try:
1213
 
            if repository_policy is not None:
1214
 
                repository_policy.configure_branch(result)
1215
 
            self.copy_content_into(result, revision_id=revision_id)
1216
 
        finally:
1217
 
            result.unlock()
1218
 
        return result
 
622
        result = self._format.initialize(to_bzrdir)
 
623
        self.copy_content_into(result, revision_id=revision_id)
 
624
        return  result
1219
625
 
1220
626
    @needs_read_lock
1221
 
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
 
627
    def sprout(self, to_bzrdir, revision_id=None):
1222
628
        """Create a new line of development from the branch, into to_bzrdir.
1223
 
 
1224
 
        to_bzrdir controls the branch format.
1225
 
 
 
629
        
1226
630
        revision_id: if not None, the revision history in the new branch will
1227
631
                     be truncated to end with revision_id.
1228
632
        """
1229
 
        if (repository_policy is not None and
1230
 
            repository_policy.requires_stacking()):
1231
 
            to_bzrdir._format.require_stacking(_skip_repo=True)
1232
 
        result = to_bzrdir.create_branch()
1233
 
        result.lock_write()
1234
 
        try:
1235
 
            if repository_policy is not None:
1236
 
                repository_policy.configure_branch(result)
1237
 
            self.copy_content_into(result, revision_id=revision_id)
1238
 
            result.set_parent(self.bzrdir.root_transport.base)
1239
 
        finally:
1240
 
            result.unlock()
 
633
        result = self._format.initialize(to_bzrdir)
 
634
        self.copy_content_into(result, revision_id=revision_id)
 
635
        result.set_parent(self.bzrdir.root_transport.base)
1241
636
        return result
1242
637
 
1243
638
    def _synchronize_history(self, destination, revision_id):
1244
639
        """Synchronize last revision and revision history between branches.
1245
640
 
1246
641
        This version is most efficient when the destination is also a
1247
 
        BzrBranch6, but works for BzrBranch5, as long as the destination's
1248
 
        repository contains all the lefthand ancestors of the intended
1249
 
        last_revision.  If not, set_last_revision_info will fail.
 
642
        BzrBranch5, but works for BzrBranch6 as long as the revision
 
643
        history is the true lefthand parent history, and all of the revisions
 
644
        are in the destination's repository.  If not, set_revision_history
 
645
        will fail.
1250
646
 
1251
647
        :param destination: The branch to copy the history into
1252
648
        :param revision_id: The revision-id to truncate history at.  May
1253
649
          be None to copy complete history.
1254
650
        """
1255
 
        source_revno, source_revision_id = self.last_revision_info()
1256
 
        if revision_id is None:
1257
 
            revno, revision_id = source_revno, source_revision_id
1258
 
        else:
1259
 
            graph = self.repository.get_graph()
 
651
        new_history = self.revision_history()
 
652
        if revision_id is not None:
 
653
            revision_id = osutils.safe_revision_id(revision_id)
1260
654
            try:
1261
 
                revno = graph.find_distance_to_null(revision_id, 
1262
 
                    [(source_revision_id, source_revno)])
1263
 
            except errors.GhostRevisionsHaveNoRevno:
1264
 
                # Default to 1, if we can't find anything else
1265
 
                revno = 1
1266
 
        destination.set_last_revision_info(revno, revision_id)
 
655
                new_history = new_history[:new_history.index(revision_id) + 1]
 
656
            except ValueError:
 
657
                rev = self.repository.get_revision(revision_id)
 
658
                new_history = rev.get_history(self.repository)[1:]
 
659
        destination.set_revision_history(new_history)
1267
660
 
1268
661
    @needs_read_lock
1269
662
    def copy_content_into(self, destination, revision_id=None):
1272
665
        revision_id: if not None, the revision history in the new branch will
1273
666
                     be truncated to end with revision_id.
1274
667
        """
1275
 
        self.update_references(destination)
1276
668
        self._synchronize_history(destination, revision_id)
1277
669
        try:
1278
670
            parent = self.get_parent()
1281
673
        else:
1282
674
            if parent:
1283
675
                destination.set_parent(parent)
1284
 
        if self._push_should_merge_tags():
1285
 
            self.tags.merge_to(destination.tags)
1286
 
 
1287
 
    def update_references(self, target):
1288
 
        if not getattr(self._format, 'supports_reference_locations', False):
1289
 
            return
1290
 
        reference_dict = self._get_all_reference_info()
1291
 
        if len(reference_dict) == 0:
1292
 
            return
1293
 
        old_base = self.base
1294
 
        new_base = target.base
1295
 
        target_reference_dict = target._get_all_reference_info()
1296
 
        for file_id, (tree_path, branch_location) in (
1297
 
            reference_dict.items()):
1298
 
            branch_location = urlutils.rebase_url(branch_location,
1299
 
                                                  old_base, new_base)
1300
 
            target_reference_dict.setdefault(
1301
 
                file_id, (tree_path, branch_location))
1302
 
        target._set_all_reference_info(target_reference_dict)
 
676
        self.tags.merge_to(destination.tags)
1303
677
 
1304
678
    @needs_read_lock
1305
 
    def check(self, refs):
 
679
    def check(self):
1306
680
        """Check consistency of the branch.
1307
681
 
1308
682
        In particular this checks that revisions given in the revision-history
1309
 
        do actually match up in the revision graph, and that they're all
 
683
        do actually match up in the revision graph, and that they're all 
1310
684
        present in the repository.
1311
 
 
 
685
        
1312
686
        Callers will typically also want to check the repository.
1313
687
 
1314
 
        :param refs: Calculated refs for this branch as specified by
1315
 
            branch._get_check_refs()
1316
688
        :return: A BranchCheckResult.
1317
689
        """
1318
 
        result = BranchCheckResult(self)
1319
 
        last_revno, last_revision_id = self.last_revision_info()
1320
 
        actual_revno = refs[('lefthand-distance', last_revision_id)]
1321
 
        if actual_revno != last_revno:
1322
 
            result.errors.append(errors.BzrCheckError(
1323
 
                'revno does not match len(mainline) %s != %s' % (
1324
 
                last_revno, actual_revno)))
1325
 
        # TODO: We should probably also check that self.revision_history
1326
 
        # matches the repository for older branch formats.
1327
 
        # If looking for the code that cross-checks repository parents against
1328
 
        # the iter_reverse_revision_history output, that is now a repository
1329
 
        # specific check.
1330
 
        return result
 
690
        mainline_parent_id = None
 
691
        for revision_id in self.revision_history():
 
692
            try:
 
693
                revision = self.repository.get_revision(revision_id)
 
694
            except errors.NoSuchRevision, e:
 
695
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
 
696
                            % revision_id)
 
697
            # In general the first entry on the revision history has no parents.
 
698
            # But it's not illegal for it to have parents listed; this can happen
 
699
            # in imports from Arch when the parents weren't reachable.
 
700
            if mainline_parent_id is not None:
 
701
                if mainline_parent_id not in revision.parent_ids:
 
702
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
 
703
                                        "parents of {%s}"
 
704
                                        % (mainline_parent_id, revision_id))
 
705
            mainline_parent_id = revision_id
 
706
        return BranchCheckResult(self)
1331
707
 
1332
708
    def _get_checkout_format(self):
1333
709
        """Return the most suitable metadir for a checkout of this branch.
1334
 
        Weaves are used if this branch's repository uses weaves.
 
710
        Weaves are used if this branch's repostory uses weaves.
1335
711
        """
1336
712
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1337
713
            from bzrlib.repofmt import weaverepo
1342
718
            format.set_branch_format(self._format)
1343
719
        return format
1344
720
 
1345
 
    def create_clone_on_transport(self, to_transport, revision_id=None,
1346
 
        stacked_on=None, create_prefix=False, use_existing_dir=False):
1347
 
        """Create a clone of this branch and its bzrdir.
1348
 
 
1349
 
        :param to_transport: The transport to clone onto.
1350
 
        :param revision_id: The revision id to use as tip in the new branch.
1351
 
            If None the tip is obtained from this branch.
1352
 
        :param stacked_on: An optional URL to stack the clone on.
1353
 
        :param create_prefix: Create any missing directories leading up to
1354
 
            to_transport.
1355
 
        :param use_existing_dir: Use an existing directory if one exists.
1356
 
        """
1357
 
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1358
 
        # clone call. Or something. 20090224 RBC/spiv.
1359
 
        if revision_id is None:
1360
 
            revision_id = self.last_revision()
1361
 
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1362
 
            revision_id=revision_id, stacked_on=stacked_on,
1363
 
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1364
 
        return dir_to.open_branch()
1365
 
 
1366
721
    def create_checkout(self, to_location, revision_id=None,
1367
 
                        lightweight=False, accelerator_tree=None,
1368
 
                        hardlink=False):
 
722
                        lightweight=False):
1369
723
        """Create a checkout of a branch.
1370
 
 
 
724
        
1371
725
        :param to_location: The url to produce the checkout at
1372
726
        :param revision_id: The revision to check out
1373
727
        :param lightweight: If True, produce a lightweight checkout, otherwise,
1374
728
        produce a bound branch (heavyweight checkout)
1375
 
        :param accelerator_tree: A tree which can be used for retrieving file
1376
 
            contents more quickly than the revision tree, i.e. a workingtree.
1377
 
            The revision tree will be used for cases where accelerator_tree's
1378
 
            content is different.
1379
 
        :param hardlink: If true, hard-link files from accelerator_tree,
1380
 
            where possible.
1381
729
        :return: The tree of the created checkout
1382
730
        """
1383
731
        t = transport.get_transport(to_location)
1384
 
        t.ensure_base()
 
732
        try:
 
733
            t.mkdir('.')
 
734
        except errors.FileExists:
 
735
            pass
1385
736
        if lightweight:
1386
737
            format = self._get_checkout_format()
1387
738
            checkout = format.initialize_on_transport(t)
1388
 
            from_branch = BranchReferenceFormat().initialize(checkout, 
1389
 
                target_branch=self)
 
739
            BranchReferenceFormat().initialize(checkout, self)
1390
740
        else:
1391
741
            format = self._get_checkout_format()
1392
742
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1393
743
                to_location, force_new_tree=False, format=format)
1394
744
            checkout = checkout_branch.bzrdir
1395
745
            checkout_branch.bind(self)
1396
 
            # pull up to the specified revision_id to set the initial
 
746
            # pull up to the specified revision_id to set the initial 
1397
747
            # branch tip correctly, and seed it with history.
1398
748
            checkout_branch.pull(self, stop_revision=revision_id)
1399
 
            from_branch=None
1400
 
        tree = checkout.create_workingtree(revision_id,
1401
 
                                           from_branch=from_branch,
1402
 
                                           accelerator_tree=accelerator_tree,
1403
 
                                           hardlink=hardlink)
 
749
        tree = checkout.create_workingtree(revision_id)
1404
750
        basis_tree = tree.basis_tree()
1405
751
        basis_tree.lock_read()
1406
752
        try:
1413
759
            basis_tree.unlock()
1414
760
        return tree
1415
761
 
1416
 
    @needs_write_lock
1417
 
    def reconcile(self, thorough=True):
1418
 
        """Make sure the data stored in this branch is consistent."""
1419
 
        from bzrlib.reconcile import BranchReconciler
1420
 
        reconciler = BranchReconciler(self, thorough=thorough)
1421
 
        reconciler.reconcile()
1422
 
        return reconciler
1423
 
 
1424
 
    def reference_parent(self, file_id, path, possible_transports=None):
 
762
    def reference_parent(self, file_id, path):
1425
763
        """Return the parent branch for a tree-reference file_id
1426
764
        :param file_id: The file_id of the tree reference
1427
765
        :param path: The path of the file_id in the tree
1428
766
        :return: A branch associated with the file_id
1429
767
        """
1430
768
        # FIXME should provide multiple branches, based on config
1431
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
1432
 
                           possible_transports=possible_transports)
 
769
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
1433
770
 
1434
771
    def supports_tags(self):
1435
772
        return self._format.supports_tags()
1436
773
 
1437
 
    def automatic_tag_name(self, revision_id):
1438
 
        """Try to automatically find the tag name for a revision.
1439
 
 
1440
 
        :param revision_id: Revision id of the revision.
1441
 
        :return: A tag name or None if no tag name could be determined.
1442
 
        """
1443
 
        for hook in Branch.hooks['automatic_tag_name']:
1444
 
            ret = hook(self, revision_id)
1445
 
            if ret is not None:
1446
 
                return ret
1447
 
        return None
1448
 
 
1449
 
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1450
 
                                         other_branch):
1451
 
        """Ensure that revision_b is a descendant of revision_a.
1452
 
 
1453
 
        This is a helper function for update_revisions.
1454
 
 
1455
 
        :raises: DivergedBranches if revision_b has diverged from revision_a.
1456
 
        :returns: True if revision_b is a descendant of revision_a.
1457
 
        """
1458
 
        relation = self._revision_relations(revision_a, revision_b, graph)
1459
 
        if relation == 'b_descends_from_a':
1460
 
            return True
1461
 
        elif relation == 'diverged':
1462
 
            raise errors.DivergedBranches(self, other_branch)
1463
 
        elif relation == 'a_descends_from_b':
1464
 
            return False
1465
 
        else:
1466
 
            raise AssertionError("invalid relation: %r" % (relation,))
1467
 
 
1468
 
    def _revision_relations(self, revision_a, revision_b, graph):
1469
 
        """Determine the relationship between two revisions.
1470
 
 
1471
 
        :returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
1472
 
        """
1473
 
        heads = graph.heads([revision_a, revision_b])
1474
 
        if heads == set([revision_b]):
1475
 
            return 'b_descends_from_a'
1476
 
        elif heads == set([revision_a, revision_b]):
1477
 
            # These branches have diverged
1478
 
            return 'diverged'
1479
 
        elif heads == set([revision_a]):
1480
 
            return 'a_descends_from_b'
1481
 
        else:
1482
 
            raise AssertionError("invalid heads: %r" % (heads,))
1483
 
 
1484
774
 
1485
775
class BranchFormat(object):
1486
776
    """An encapsulation of the initialization and open routines for a format.
1490
780
     * a format string,
1491
781
     * an open routine.
1492
782
 
1493
 
    Formats are placed in an dict by their format string for reference
 
783
    Formats are placed in an dict by their format string for reference 
1494
784
    during branch opening. Its not required that these be instances, they
1495
 
    can be classes themselves with class methods - it simply depends on
 
785
    can be classes themselves with class methods - it simply depends on 
1496
786
    whether state is needed for a given format or not.
1497
787
 
1498
788
    Once a format is deprecated, just deprecate the initialize and open
1499
 
    methods on the format class. Do not deprecate the object, as the
 
789
    methods on the format class. Do not deprecate the object, as the 
1500
790
    object will be created every time regardless.
1501
791
    """
1502
792
 
1506
796
    _formats = {}
1507
797
    """The known formats."""
1508
798
 
1509
 
    can_set_append_revisions_only = True
1510
 
 
1511
 
    def __eq__(self, other):
1512
 
        return self.__class__ is other.__class__
1513
 
 
1514
 
    def __ne__(self, other):
1515
 
        return not (self == other)
1516
 
 
1517
799
    @classmethod
1518
 
    def find_format(klass, a_bzrdir, name=None):
 
800
    def find_format(klass, a_bzrdir):
1519
801
        """Return the format for the branch object in a_bzrdir."""
1520
802
        try:
1521
 
            transport = a_bzrdir.get_branch_transport(None, name=name)
1522
 
            format_string = transport.get_bytes("format")
 
803
            transport = a_bzrdir.get_branch_transport(None)
 
804
            format_string = transport.get("format").read()
1523
805
            return klass._formats[format_string]
1524
 
        except errors.NoSuchFile:
1525
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
 
806
        except NoSuchFile:
 
807
            raise NotBranchError(path=transport.base)
1526
808
        except KeyError:
1527
 
            raise errors.UnknownFormatError(format=format_string, kind='branch')
 
809
            raise errors.UnknownFormatError(format=format_string)
1528
810
 
1529
811
    @classmethod
1530
812
    def get_default_format(klass):
1531
813
        """Return the current default format."""
1532
814
        return klass._default_format
1533
815
 
1534
 
    def get_reference(self, a_bzrdir):
1535
 
        """Get the target reference of the branch in a_bzrdir.
1536
 
 
1537
 
        format probing must have been completed before calling
1538
 
        this method - it is assumed that the format of the branch
1539
 
        in a_bzrdir is correct.
1540
 
 
1541
 
        :param a_bzrdir: The bzrdir to get the branch data from.
1542
 
        :return: None if the branch is not a reference branch.
1543
 
        """
1544
 
        return None
1545
 
 
1546
 
    @classmethod
1547
 
    def set_reference(self, a_bzrdir, to_branch):
1548
 
        """Set the target reference of the branch in a_bzrdir.
1549
 
 
1550
 
        format probing must have been completed before calling
1551
 
        this method - it is assumed that the format of the branch
1552
 
        in a_bzrdir is correct.
1553
 
 
1554
 
        :param a_bzrdir: The bzrdir to set the branch reference for.
1555
 
        :param to_branch: branch that the checkout is to reference
1556
 
        """
1557
 
        raise NotImplementedError(self.set_reference)
1558
 
 
1559
816
    def get_format_string(self):
1560
817
        """Return the ASCII format string that identifies this format."""
1561
818
        raise NotImplementedError(self.get_format_string)
1564
821
        """Return the short format description for this format."""
1565
822
        raise NotImplementedError(self.get_format_description)
1566
823
 
1567
 
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1568
 
        hooks = Branch.hooks['post_branch_init']
1569
 
        if not hooks:
1570
 
            return
1571
 
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
1572
 
        for hook in hooks:
1573
 
            hook(params)
1574
 
 
1575
 
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1576
 
                           lock_type='metadir', set_format=True):
 
824
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
 
825
                           set_format=True):
1577
826
        """Initialize a branch in a bzrdir, with specified files
1578
827
 
1579
828
        :param a_bzrdir: The bzrdir to initialize the branch in
1580
829
        :param utf8_files: The files to create as a list of
1581
830
            (filename, content) tuples
1582
 
        :param name: Name of colocated branch to create, if any
1583
831
        :param set_format: If True, set the format with
1584
832
            self.get_format_string.  (BzrBranch4 has its format set
1585
833
            elsewhere)
1586
834
        :return: a branch in this format
1587
835
        """
1588
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1589
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
836
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
837
        branch_transport = a_bzrdir.get_branch_transport(self)
1590
838
        lock_map = {
1591
839
            'metadir': ('lock', lockdir.LockDir),
1592
840
            'branch4': ('branch-lock', lockable_files.TransportLock),
1595
843
        control_files = lockable_files.LockableFiles(branch_transport,
1596
844
            lock_name, lock_class)
1597
845
        control_files.create_lock()
1598
 
        try:
1599
 
            control_files.lock_write()
1600
 
        except errors.LockContention:
1601
 
            if lock_type != 'branch4':
1602
 
                raise
1603
 
            lock_taken = False
1604
 
        else:
1605
 
            lock_taken = True
 
846
        control_files.lock_write()
1606
847
        if set_format:
1607
 
            utf8_files += [('format', self.get_format_string())]
 
848
            control_files.put_utf8('format', self.get_format_string())
1608
849
        try:
1609
 
            for (filename, content) in utf8_files:
1610
 
                branch_transport.put_bytes(
1611
 
                    filename, content,
1612
 
                    mode=a_bzrdir._get_file_mode())
 
850
            for file, content in utf8_files:
 
851
                control_files.put_utf8(file, content)
1613
852
        finally:
1614
 
            if lock_taken:
1615
 
                control_files.unlock()
1616
 
        branch = self.open(a_bzrdir, name, _found=True)
1617
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1618
 
        return branch
 
853
            control_files.unlock()
 
854
        return self.open(a_bzrdir, _found=True)
1619
855
 
1620
 
    def initialize(self, a_bzrdir, name=None):
1621
 
        """Create a branch of this format in a_bzrdir.
1622
 
        
1623
 
        :param name: Name of the colocated branch to create.
1624
 
        """
 
856
    def initialize(self, a_bzrdir):
 
857
        """Create a branch of this format in a_bzrdir."""
1625
858
        raise NotImplementedError(self.initialize)
1626
859
 
1627
860
    def is_supported(self):
1628
861
        """Is this format supported?
1629
862
 
1630
863
        Supported formats can be initialized and opened.
1631
 
        Unsupported formats may not support initialization or committing or
 
864
        Unsupported formats may not support initialization or committing or 
1632
865
        some other features depending on the reason for not being supported.
1633
866
        """
1634
867
        return True
1635
868
 
1636
 
    def make_tags(self, branch):
1637
 
        """Create a tags object for branch.
1638
 
 
1639
 
        This method is on BranchFormat, because BranchFormats are reflected
1640
 
        over the wire via network_name(), whereas full Branch instances require
1641
 
        multiple VFS method calls to operate at all.
1642
 
 
1643
 
        The default implementation returns a disabled-tags instance.
1644
 
 
1645
 
        Note that it is normal for branch to be a RemoteBranch when using tags
1646
 
        on a RemoteBranch.
1647
 
        """
1648
 
        return DisabledTags(branch)
1649
 
 
1650
 
    def network_name(self):
1651
 
        """A simple byte string uniquely identifying this format for RPC calls.
1652
 
 
1653
 
        MetaDir branch formats use their disk format string to identify the
1654
 
        repository over the wire. All in one formats such as bzr < 0.8, and
1655
 
        foreign formats like svn/git and hg should use some marker which is
1656
 
        unique and immutable.
1657
 
        """
1658
 
        raise NotImplementedError(self.network_name)
1659
 
 
1660
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
869
    def open(self, a_bzrdir, _found=False):
1661
870
        """Return the branch object for a_bzrdir
1662
871
 
1663
 
        :param a_bzrdir: A BzrDir that contains a branch.
1664
 
        :param name: Name of colocated branch to open
1665
 
        :param _found: a private parameter, do not use it. It is used to
1666
 
            indicate if format probing has already be done.
1667
 
        :param ignore_fallbacks: when set, no fallback branches will be opened
1668
 
            (if there are any).  Default is to open fallbacks.
 
872
        _found is a private parameter, do not use it. It is used to indicate
 
873
               if format probing has already be done.
1669
874
        """
1670
875
        raise NotImplementedError(self.open)
1671
876
 
1672
877
    @classmethod
1673
878
    def register_format(klass, format):
1674
 
        """Register a metadir format."""
1675
879
        klass._formats[format.get_format_string()] = format
1676
 
        # Metadir formats have a network name of their format string, and get
1677
 
        # registered as class factories.
1678
 
        network_format_registry.register(format.get_format_string(), format.__class__)
1679
880
 
1680
881
    @classmethod
1681
882
    def set_default_format(klass, format):
1682
883
        klass._default_format = format
1683
884
 
1684
 
    def supports_set_append_revisions_only(self):
1685
 
        """True if this format supports set_append_revisions_only."""
1686
 
        return False
1687
 
 
1688
 
    def supports_stacking(self):
1689
 
        """True if this format records a stacked-on branch."""
1690
 
        return False
1691
 
 
1692
885
    @classmethod
1693
886
    def unregister_format(klass, format):
 
887
        assert klass._formats[format.get_format_string()] is format
1694
888
        del klass._formats[format.get_format_string()]
1695
889
 
1696
890
    def __str__(self):
1697
 
        return self.get_format_description().rstrip()
 
891
        return self.get_format_string().rstrip()
1698
892
 
1699
893
    def supports_tags(self):
1700
894
        """True if this format supports tags stored in the branch"""
1701
895
        return False  # by default
1702
896
 
 
897
    # XXX: Probably doesn't really belong here -- mbp 20070212
 
898
    def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
 
899
            lock_class):
 
900
        branch_transport = a_bzrdir.get_branch_transport(self)
 
901
        control_files = lockable_files.LockableFiles(branch_transport,
 
902
            lock_filename, lock_class)
 
903
        control_files.create_lock()
 
904
        control_files.lock_write()
 
905
        try:
 
906
            for filename, content in utf8_files:
 
907
                control_files.put_utf8(filename, content)
 
908
        finally:
 
909
            control_files.unlock()
 
910
 
1703
911
 
1704
912
class BranchHooks(Hooks):
1705
913
    """A dictionary mapping hook name to a list of callables for branch hooks.
1706
 
 
 
914
    
1707
915
    e.g. ['set_rh'] Is the list of items to be called when the
1708
916
    set_revision_history function is invoked.
1709
917
    """
1715
923
        notified.
1716
924
        """
1717
925
        Hooks.__init__(self)
1718
 
        self.create_hook(HookPoint('set_rh',
1719
 
            "Invoked whenever the revision history has been set via "
1720
 
            "set_revision_history. The api signature is (branch, "
1721
 
            "revision_history), and the branch will be write-locked. "
1722
 
            "The set_rh hook can be expensive for bzr to trigger, a better "
1723
 
            "hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1724
 
        self.create_hook(HookPoint('open',
1725
 
            "Called with the Branch object that has been opened after a "
1726
 
            "branch is opened.", (1, 8), None))
1727
 
        self.create_hook(HookPoint('post_push',
1728
 
            "Called after a push operation completes. post_push is called "
1729
 
            "with a bzrlib.branch.BranchPushResult object and only runs in the "
1730
 
            "bzr client.", (0, 15), None))
1731
 
        self.create_hook(HookPoint('post_pull',
1732
 
            "Called after a pull operation completes. post_pull is called "
1733
 
            "with a bzrlib.branch.PullResult object and only runs in the "
1734
 
            "bzr client.", (0, 15), None))
1735
 
        self.create_hook(HookPoint('pre_commit',
1736
 
            "Called after a commit is calculated but before it is is "
1737
 
            "completed. pre_commit is called with (local, master, old_revno, "
1738
 
            "old_revid, future_revno, future_revid, tree_delta, future_tree"
1739
 
            "). old_revid is NULL_REVISION for the first commit to a branch, "
1740
 
            "tree_delta is a TreeDelta object describing changes from the "
1741
 
            "basis revision. hooks MUST NOT modify this delta. "
1742
 
            " future_tree is an in-memory tree obtained from "
1743
 
            "CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1744
 
            "tree.", (0,91), None))
1745
 
        self.create_hook(HookPoint('post_commit',
1746
 
            "Called in the bzr client after a commit has completed. "
1747
 
            "post_commit is called with (local, master, old_revno, old_revid, "
1748
 
            "new_revno, new_revid). old_revid is NULL_REVISION for the first "
1749
 
            "commit to a branch.", (0, 15), None))
1750
 
        self.create_hook(HookPoint('post_uncommit',
1751
 
            "Called in the bzr client after an uncommit completes. "
1752
 
            "post_uncommit is called with (local, master, old_revno, "
1753
 
            "old_revid, new_revno, new_revid) where local is the local branch "
1754
 
            "or None, master is the target branch, and an empty branch "
1755
 
            "receives new_revno of 0, new_revid of None.", (0, 15), None))
1756
 
        self.create_hook(HookPoint('pre_change_branch_tip',
1757
 
            "Called in bzr client and server before a change to the tip of a "
1758
 
            "branch is made. pre_change_branch_tip is called with a "
1759
 
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1760
 
            "commit, uncommit will all trigger this hook.", (1, 6), None))
1761
 
        self.create_hook(HookPoint('post_change_branch_tip',
1762
 
            "Called in bzr client and server after a change to the tip of a "
1763
 
            "branch is made. post_change_branch_tip is called with a "
1764
 
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1765
 
            "commit, uncommit will all trigger this hook.", (1, 4), None))
1766
 
        self.create_hook(HookPoint('transform_fallback_location',
1767
 
            "Called when a stacked branch is activating its fallback "
1768
 
            "locations. transform_fallback_location is called with (branch, "
1769
 
            "url), and should return a new url. Returning the same url "
1770
 
            "allows it to be used as-is, returning a different one can be "
1771
 
            "used to cause the branch to stack on a closer copy of that "
1772
 
            "fallback_location. Note that the branch cannot have history "
1773
 
            "accessing methods called on it during this hook because the "
1774
 
            "fallback locations have not been activated. When there are "
1775
 
            "multiple hooks installed for transform_fallback_location, "
1776
 
            "all are called with the url returned from the previous hook."
1777
 
            "The order is however undefined.", (1, 9), None))
1778
 
        self.create_hook(HookPoint('automatic_tag_name',
1779
 
            "Called to determine an automatic tag name for a revision."
1780
 
            "automatic_tag_name is called with (branch, revision_id) and "
1781
 
            "should return a tag name or None if no tag name could be "
1782
 
            "determined. The first non-None tag name returned will be used.",
1783
 
            (2, 2), None))
1784
 
        self.create_hook(HookPoint('post_branch_init',
1785
 
            "Called after new branch initialization completes. "
1786
 
            "post_branch_init is called with a "
1787
 
            "bzrlib.branch.BranchInitHookParams. "
1788
 
            "Note that init, branch and checkout (both heavyweight and "
1789
 
            "lightweight) will all trigger this hook.", (2, 2), None))
1790
 
        self.create_hook(HookPoint('post_switch',
1791
 
            "Called after a checkout switches branch. "
1792
 
            "post_switch is called with a "
1793
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1794
 
 
 
926
        # Introduced in 0.15:
 
927
        # invoked whenever the revision history has been set
 
928
        # with set_revision_history. The api signature is
 
929
        # (branch, revision_history), and the branch will
 
930
        # be write-locked.
 
931
        self['set_rh'] = []
 
932
        # invoked after a push operation completes.
 
933
        # the api signature is
 
934
        # (push_result)
 
935
        # containing the members
 
936
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
937
        # where local is the local branch or None, master is the target 
 
938
        # master branch, and the rest should be self explanatory. The source
 
939
        # is read locked and the target branches write locked. Source will
 
940
        # be the local low-latency branch.
 
941
        self['post_push'] = []
 
942
        # invoked after a pull operation completes.
 
943
        # the api signature is
 
944
        # (pull_result)
 
945
        # containing the members
 
946
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
947
        # where local is the local branch or None, master is the target 
 
948
        # master branch, and the rest should be self explanatory. The source
 
949
        # is read locked and the target branches write locked. The local
 
950
        # branch is the low-latency branch.
 
951
        self['post_pull'] = []
 
952
        # invoked after a commit operation completes.
 
953
        # the api signature is 
 
954
        # (local, master, old_revno, old_revid, new_revno, new_revid)
 
955
        # old_revid is NULL_REVISION for the first commit to a branch.
 
956
        self['post_commit'] = []
 
957
        # invoked after a uncommit operation completes.
 
958
        # the api signature is
 
959
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
 
960
        # local is the local branch or None, master is the target branch,
 
961
        # and an empty branch recieves new_revno of 0, new_revid of None.
 
962
        self['post_uncommit'] = []
1795
963
 
1796
964
 
1797
965
# install the default hooks into the Branch class.
1798
966
Branch.hooks = BranchHooks()
1799
967
 
1800
968
 
1801
 
class ChangeBranchTipParams(object):
1802
 
    """Object holding parameters passed to *_change_branch_tip hooks.
1803
 
 
1804
 
    There are 5 fields that hooks may wish to access:
1805
 
 
1806
 
    :ivar branch: the branch being changed
1807
 
    :ivar old_revno: revision number before the change
1808
 
    :ivar new_revno: revision number after the change
1809
 
    :ivar old_revid: revision id before the change
1810
 
    :ivar new_revid: revision id after the change
1811
 
 
1812
 
    The revid fields are strings. The revno fields are integers.
1813
 
    """
1814
 
 
1815
 
    def __init__(self, branch, old_revno, new_revno, old_revid, new_revid):
1816
 
        """Create a group of ChangeBranchTip parameters.
1817
 
 
1818
 
        :param branch: The branch being changed.
1819
 
        :param old_revno: Revision number before the change.
1820
 
        :param new_revno: Revision number after the change.
1821
 
        :param old_revid: Tip revision id before the change.
1822
 
        :param new_revid: Tip revision id after the change.
1823
 
        """
1824
 
        self.branch = branch
1825
 
        self.old_revno = old_revno
1826
 
        self.new_revno = new_revno
1827
 
        self.old_revid = old_revid
1828
 
        self.new_revid = new_revid
1829
 
 
1830
 
    def __eq__(self, other):
1831
 
        return self.__dict__ == other.__dict__
1832
 
 
1833
 
    def __repr__(self):
1834
 
        return "<%s of %s from (%s, %s) to (%s, %s)>" % (
1835
 
            self.__class__.__name__, self.branch,
1836
 
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1837
 
 
1838
 
 
1839
 
class BranchInitHookParams(object):
1840
 
    """Object holding parameters passed to *_branch_init hooks.
1841
 
 
1842
 
    There are 4 fields that hooks may wish to access:
1843
 
 
1844
 
    :ivar format: the branch format
1845
 
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
1846
 
    :ivar name: name of colocated branch, if any (or None)
1847
 
    :ivar branch: the branch created
1848
 
 
1849
 
    Note that for lightweight checkouts, the bzrdir and format fields refer to
1850
 
    the checkout, hence they are different from the corresponding fields in
1851
 
    branch, which refer to the original branch.
1852
 
    """
1853
 
 
1854
 
    def __init__(self, format, a_bzrdir, name, branch):
1855
 
        """Create a group of BranchInitHook parameters.
1856
 
 
1857
 
        :param format: the branch format
1858
 
        :param a_bzrdir: the BzrDir where the branch will be/has been
1859
 
            initialized
1860
 
        :param name: name of colocated branch, if any (or None)
1861
 
        :param branch: the branch created
1862
 
 
1863
 
        Note that for lightweight checkouts, the bzrdir and format fields refer
1864
 
        to the checkout, hence they are different from the corresponding fields
1865
 
        in branch, which refer to the original branch.
1866
 
        """
1867
 
        self.format = format
1868
 
        self.bzrdir = a_bzrdir
1869
 
        self.name = name
1870
 
        self.branch = branch
1871
 
 
1872
 
    def __eq__(self, other):
1873
 
        return self.__dict__ == other.__dict__
1874
 
 
1875
 
    def __repr__(self):
1876
 
        if self.branch:
1877
 
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
1878
 
        else:
1879
 
            return "<%s of format:%s bzrdir:%s>" % (
1880
 
                self.__class__.__name__, self.branch,
1881
 
                self.format, self.bzrdir)
1882
 
 
1883
 
 
1884
 
class SwitchHookParams(object):
1885
 
    """Object holding parameters passed to *_switch hooks.
1886
 
 
1887
 
    There are 4 fields that hooks may wish to access:
1888
 
 
1889
 
    :ivar control_dir: BzrDir of the checkout to change
1890
 
    :ivar to_branch: branch that the checkout is to reference
1891
 
    :ivar force: skip the check for local commits in a heavy checkout
1892
 
    :ivar revision_id: revision ID to switch to (or None)
1893
 
    """
1894
 
 
1895
 
    def __init__(self, control_dir, to_branch, force, revision_id):
1896
 
        """Create a group of SwitchHook parameters.
1897
 
 
1898
 
        :param control_dir: BzrDir of the checkout to change
1899
 
        :param to_branch: branch that the checkout is to reference
1900
 
        :param force: skip the check for local commits in a heavy checkout
1901
 
        :param revision_id: revision ID to switch to (or None)
1902
 
        """
1903
 
        self.control_dir = control_dir
1904
 
        self.to_branch = to_branch
1905
 
        self.force = force
1906
 
        self.revision_id = revision_id
1907
 
 
1908
 
    def __eq__(self, other):
1909
 
        return self.__dict__ == other.__dict__
1910
 
 
1911
 
    def __repr__(self):
1912
 
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1913
 
            self.control_dir, self.to_branch,
1914
 
            self.revision_id)
1915
 
 
1916
 
 
1917
969
class BzrBranchFormat4(BranchFormat):
1918
970
    """Bzr branch format 4.
1919
971
 
1926
978
        """See BranchFormat.get_format_description()."""
1927
979
        return "Branch format 4"
1928
980
 
1929
 
    def initialize(self, a_bzrdir, name=None):
 
981
    def initialize(self, a_bzrdir):
1930
982
        """Create a branch of this format in a_bzrdir."""
1931
983
        utf8_files = [('revision-history', ''),
1932
984
                      ('branch-name', ''),
1933
985
                      ]
1934
 
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
 
986
        return self._initialize_helper(a_bzrdir, utf8_files,
1935
987
                                       lock_type='branch4', set_format=False)
1936
988
 
1937
989
    def __init__(self):
1938
990
        super(BzrBranchFormat4, self).__init__()
1939
991
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
1940
992
 
1941
 
    def network_name(self):
1942
 
        """The network name for this format is the control dirs disk label."""
1943
 
        return self._matchingbzrdir.get_format_string()
 
993
    def open(self, a_bzrdir, _found=False):
 
994
        """Return the branch object for a_bzrdir
1944
995
 
1945
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1946
 
        """See BranchFormat.open()."""
 
996
        _found is a private parameter, do not use it. It is used to indicate
 
997
               if format probing has already be done.
 
998
        """
1947
999
        if not _found:
1948
1000
            # we are being called directly and must probe.
1949
1001
            raise NotImplementedError
1950
1002
        return BzrBranch(_format=self,
1951
1003
                         _control_files=a_bzrdir._control_files,
1952
1004
                         a_bzrdir=a_bzrdir,
1953
 
                         name=name,
1954
1005
                         _repository=a_bzrdir.open_repository())
1955
1006
 
1956
1007
    def __str__(self):
1957
1008
        return "Bazaar-NG branch format 4"
1958
1009
 
1959
1010
 
1960
 
class BranchFormatMetadir(BranchFormat):
1961
 
    """Common logic for meta-dir based branch formats."""
1962
 
 
1963
 
    def _branch_class(self):
1964
 
        """What class to instantiate on open calls."""
1965
 
        raise NotImplementedError(self._branch_class)
1966
 
 
1967
 
    def network_name(self):
1968
 
        """A simple byte string uniquely identifying this format for RPC calls.
1969
 
 
1970
 
        Metadir branch formats use their format string.
1971
 
        """
1972
 
        return self.get_format_string()
1973
 
 
1974
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1975
 
        """See BranchFormat.open()."""
1976
 
        if not _found:
1977
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
1978
 
            if format.__class__ != self.__class__:
1979
 
                raise AssertionError("wrong format %r found for %r" %
1980
 
                    (format, self))
1981
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
1982
 
        try:
1983
 
            control_files = lockable_files.LockableFiles(transport, 'lock',
1984
 
                                                         lockdir.LockDir)
1985
 
            return self._branch_class()(_format=self,
1986
 
                              _control_files=control_files,
1987
 
                              name=name,
1988
 
                              a_bzrdir=a_bzrdir,
1989
 
                              _repository=a_bzrdir.find_repository(),
1990
 
                              ignore_fallbacks=ignore_fallbacks)
1991
 
        except errors.NoSuchFile:
1992
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1993
 
 
1994
 
    def __init__(self):
1995
 
        super(BranchFormatMetadir, self).__init__()
1996
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1997
 
        self._matchingbzrdir.set_branch_format(self)
1998
 
 
1999
 
    def supports_tags(self):
2000
 
        return True
2001
 
 
2002
 
 
2003
 
class BzrBranchFormat5(BranchFormatMetadir):
 
1011
class BzrBranchFormat5(BranchFormat):
2004
1012
    """Bzr branch format 5.
2005
1013
 
2006
1014
    This format has:
2013
1021
    This format is new in bzr 0.8.
2014
1022
    """
2015
1023
 
2016
 
    def _branch_class(self):
2017
 
        return BzrBranch5
2018
 
 
2019
1024
    def get_format_string(self):
2020
1025
        """See BranchFormat.get_format_string()."""
2021
1026
        return "Bazaar-NG branch format 5\n"
2023
1028
    def get_format_description(self):
2024
1029
        """See BranchFormat.get_format_description()."""
2025
1030
        return "Branch format 5"
2026
 
 
2027
 
    def initialize(self, a_bzrdir, name=None):
 
1031
        
 
1032
    def initialize(self, a_bzrdir):
2028
1033
        """Create a branch of this format in a_bzrdir."""
2029
1034
        utf8_files = [('revision-history', ''),
2030
1035
                      ('branch-name', ''),
2031
1036
                      ]
2032
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2033
 
 
2034
 
    def supports_tags(self):
2035
 
        return False
2036
 
 
2037
 
 
2038
 
class BzrBranchFormat6(BranchFormatMetadir):
2039
 
    """Branch format with last-revision and tags.
 
1037
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1038
 
 
1039
    def __init__(self):
 
1040
        super(BzrBranchFormat5, self).__init__()
 
1041
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1042
 
 
1043
    def open(self, a_bzrdir, _found=False):
 
1044
        """Return the branch object for a_bzrdir
 
1045
 
 
1046
        _found is a private parameter, do not use it. It is used to indicate
 
1047
               if format probing has already be done.
 
1048
        """
 
1049
        if not _found:
 
1050
            format = BranchFormat.find_format(a_bzrdir)
 
1051
            assert format.__class__ == self.__class__
 
1052
        transport = a_bzrdir.get_branch_transport(None)
 
1053
        control_files = lockable_files.LockableFiles(transport, 'lock',
 
1054
                                                     lockdir.LockDir)
 
1055
        return BzrBranch5(_format=self,
 
1056
                          _control_files=control_files,
 
1057
                          a_bzrdir=a_bzrdir,
 
1058
                          _repository=a_bzrdir.find_repository())
 
1059
 
 
1060
 
 
1061
class BzrBranchFormat6(BzrBranchFormat5):
 
1062
    """Branch format with last-revision
2040
1063
 
2041
1064
    Unlike previous formats, this has no explicit revision history. Instead,
2042
1065
    this just stores the last-revision, and the left-hand history leading
2043
1066
    up to there is the history.
2044
1067
 
2045
1068
    This format was introduced in bzr 0.15
2046
 
    and became the default in 0.91.
2047
1069
    """
2048
1070
 
2049
 
    def _branch_class(self):
2050
 
        return BzrBranch6
2051
 
 
2052
1071
    def get_format_string(self):
2053
1072
        """See BranchFormat.get_format_string()."""
2054
1073
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
2057
1076
        """See BranchFormat.get_format_description()."""
2058
1077
        return "Branch format 6"
2059
1078
 
2060
 
    def initialize(self, a_bzrdir, name=None):
2061
 
        """Create a branch of this format in a_bzrdir."""
2062
 
        utf8_files = [('last-revision', '0 null:\n'),
2063
 
                      ('branch.conf', ''),
2064
 
                      ('tags', ''),
2065
 
                      ]
2066
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2067
 
 
2068
 
    def make_tags(self, branch):
2069
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
2070
 
        return BasicTags(branch)
2071
 
 
2072
 
    def supports_set_append_revisions_only(self):
2073
 
        return True
2074
 
 
2075
 
 
2076
 
class BzrBranchFormat8(BranchFormatMetadir):
2077
 
    """Metadir format supporting storing locations of subtree branches."""
2078
 
 
2079
 
    def _branch_class(self):
2080
 
        return BzrBranch8
2081
 
 
2082
 
    def get_format_string(self):
2083
 
        """See BranchFormat.get_format_string()."""
2084
 
        return "Bazaar Branch Format 8 (needs bzr 1.15)\n"
2085
 
 
2086
 
    def get_format_description(self):
2087
 
        """See BranchFormat.get_format_description()."""
2088
 
        return "Branch format 8"
2089
 
 
2090
 
    def initialize(self, a_bzrdir, name=None):
2091
 
        """Create a branch of this format in a_bzrdir."""
2092
 
        utf8_files = [('last-revision', '0 null:\n'),
2093
 
                      ('branch.conf', ''),
2094
 
                      ('tags', ''),
2095
 
                      ('references', '')
2096
 
                      ]
2097
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2098
 
 
2099
 
    def __init__(self):
2100
 
        super(BzrBranchFormat8, self).__init__()
2101
 
        self._matchingbzrdir.repository_format = \
2102
 
            RepositoryFormatKnitPack5RichRoot()
2103
 
 
2104
 
    def make_tags(self, branch):
2105
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
2106
 
        return BasicTags(branch)
2107
 
 
2108
 
    def supports_set_append_revisions_only(self):
2109
 
        return True
2110
 
 
2111
 
    def supports_stacking(self):
2112
 
        return True
2113
 
 
2114
 
    supports_reference_locations = True
2115
 
 
2116
 
 
2117
 
class BzrBranchFormat7(BzrBranchFormat8):
2118
 
    """Branch format with last-revision, tags, and a stacked location pointer.
2119
 
 
2120
 
    The stacked location pointer is passed down to the repository and requires
2121
 
    a repository format with supports_external_lookups = True.
2122
 
 
2123
 
    This format was introduced in bzr 1.6.
2124
 
    """
2125
 
 
2126
 
    def initialize(self, a_bzrdir, name=None):
2127
 
        """Create a branch of this format in a_bzrdir."""
2128
 
        utf8_files = [('last-revision', '0 null:\n'),
2129
 
                      ('branch.conf', ''),
2130
 
                      ('tags', ''),
2131
 
                      ]
2132
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2133
 
 
2134
 
    def _branch_class(self):
2135
 
        return BzrBranch7
2136
 
 
2137
 
    def get_format_string(self):
2138
 
        """See BranchFormat.get_format_string()."""
2139
 
        return "Bazaar Branch Format 7 (needs bzr 1.6)\n"
2140
 
 
2141
 
    def get_format_description(self):
2142
 
        """See BranchFormat.get_format_description()."""
2143
 
        return "Branch format 7"
2144
 
 
2145
 
    def supports_set_append_revisions_only(self):
2146
 
        return True
2147
 
 
2148
 
    supports_reference_locations = False
 
1079
    def initialize(self, a_bzrdir):
 
1080
        """Create a branch of this format in a_bzrdir."""
 
1081
        utf8_files = [('last-revision', '0 null:\n'),
 
1082
                      ('branch-name', ''),
 
1083
                      ('branch.conf', ''),
 
1084
                      ('tags', ''),
 
1085
                      ]
 
1086
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1087
 
 
1088
    def open(self, a_bzrdir, _found=False):
 
1089
        """Return the branch object for a_bzrdir
 
1090
 
 
1091
        _found is a private parameter, do not use it. It is used to indicate
 
1092
               if format probing has already be done.
 
1093
        """
 
1094
        if not _found:
 
1095
            format = BranchFormat.find_format(a_bzrdir)
 
1096
            assert format.__class__ == self.__class__
 
1097
        transport = a_bzrdir.get_branch_transport(None)
 
1098
        control_files = lockable_files.LockableFiles(transport, 'lock',
 
1099
                                                     lockdir.LockDir)
 
1100
        return BzrBranch6(_format=self,
 
1101
                          _control_files=control_files,
 
1102
                          a_bzrdir=a_bzrdir,
 
1103
                          _repository=a_bzrdir.find_repository())
 
1104
 
 
1105
    def supports_tags(self):
 
1106
        return True
2149
1107
 
2150
1108
 
2151
1109
class BranchReferenceFormat(BranchFormat):
2166
1124
    def get_format_description(self):
2167
1125
        """See BranchFormat.get_format_description()."""
2168
1126
        return "Checkout reference format 1"
2169
 
 
2170
 
    def get_reference(self, a_bzrdir):
2171
 
        """See BranchFormat.get_reference()."""
2172
 
        transport = a_bzrdir.get_branch_transport(None)
2173
 
        return transport.get_bytes('location')
2174
 
 
2175
 
    def set_reference(self, a_bzrdir, to_branch):
2176
 
        """See BranchFormat.set_reference()."""
2177
 
        transport = a_bzrdir.get_branch_transport(None)
2178
 
        location = transport.put_bytes('location', to_branch.base)
2179
 
 
2180
 
    def initialize(self, a_bzrdir, name=None, target_branch=None):
 
1127
        
 
1128
    def initialize(self, a_bzrdir, target_branch=None):
2181
1129
        """Create a branch of this format in a_bzrdir."""
2182
1130
        if target_branch is None:
2183
1131
            # this format does not implement branch itself, thus the implicit
2184
1132
            # creation contract must see it as uninitializable
2185
1133
            raise errors.UninitializableFormat(self)
2186
 
        mutter('creating branch reference in %s', a_bzrdir.user_url)
2187
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
1134
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
1135
        branch_transport = a_bzrdir.get_branch_transport(self)
2188
1136
        branch_transport.put_bytes('location',
2189
 
            target_branch.bzrdir.user_url)
 
1137
            target_branch.bzrdir.root_transport.base)
2190
1138
        branch_transport.put_bytes('format', self.get_format_string())
2191
 
        branch = self.open(
2192
 
            a_bzrdir, name, _found=True,
2193
 
            possible_transports=[target_branch.bzrdir.root_transport])
2194
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2195
 
        return branch
 
1139
        return self.open(a_bzrdir, _found=True)
2196
1140
 
2197
1141
    def __init__(self):
2198
1142
        super(BranchReferenceFormat, self).__init__()
2199
1143
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2200
 
        self._matchingbzrdir.set_branch_format(self)
2201
1144
 
2202
1145
    def _make_reference_clone_function(format, a_branch):
2203
1146
        """Create a clone() routine for a branch dynamically."""
2204
 
        def clone(to_bzrdir, revision_id=None,
2205
 
            repository_policy=None):
 
1147
        def clone(to_bzrdir, revision_id=None):
2206
1148
            """See Branch.clone()."""
2207
 
            return format.initialize(to_bzrdir, target_branch=a_branch)
 
1149
            return format.initialize(to_bzrdir, a_branch)
2208
1150
            # cannot obey revision_id limits when cloning a reference ...
2209
1151
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2210
1152
            # emit some sort of warning/error to the caller ?!
2211
1153
        return clone
2212
1154
 
2213
 
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2214
 
             possible_transports=None, ignore_fallbacks=False):
 
1155
    def open(self, a_bzrdir, _found=False):
2215
1156
        """Return the branch that the branch reference in a_bzrdir points at.
2216
1157
 
2217
 
        :param a_bzrdir: A BzrDir that contains a branch.
2218
 
        :param name: Name of colocated branch to open, if any
2219
 
        :param _found: a private parameter, do not use it. It is used to
2220
 
            indicate if format probing has already be done.
2221
 
        :param ignore_fallbacks: when set, no fallback branches will be opened
2222
 
            (if there are any).  Default is to open fallbacks.
2223
 
        :param location: The location of the referenced branch.  If
2224
 
            unspecified, this will be determined from the branch reference in
2225
 
            a_bzrdir.
2226
 
        :param possible_transports: An optional reusable transports list.
 
1158
        _found is a private parameter, do not use it. It is used to indicate
 
1159
               if format probing has already be done.
2227
1160
        """
2228
1161
        if not _found:
2229
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
2230
 
            if format.__class__ != self.__class__:
2231
 
                raise AssertionError("wrong format %r found for %r" %
2232
 
                    (format, self))
2233
 
        if location is None:
2234
 
            location = self.get_reference(a_bzrdir)
2235
 
        real_bzrdir = bzrdir.BzrDir.open(
2236
 
            location, possible_transports=possible_transports)
2237
 
        result = real_bzrdir.open_branch(name=name, 
2238
 
            ignore_fallbacks=ignore_fallbacks)
 
1162
            format = BranchFormat.find_format(a_bzrdir)
 
1163
            assert format.__class__ == self.__class__
 
1164
        transport = a_bzrdir.get_branch_transport(None)
 
1165
        real_bzrdir = bzrdir.BzrDir.open(transport.get('location').read())
 
1166
        result = real_bzrdir.open_branch()
2239
1167
        # this changes the behaviour of result.clone to create a new reference
2240
1168
        # rather than a copy of the content of the branch.
2241
1169
        # I did not use a proxy object because that needs much more extensive
2248
1176
        return result
2249
1177
 
2250
1178
 
2251
 
network_format_registry = registry.FormatRegistry()
2252
 
"""Registry of formats indexed by their network name.
2253
 
 
2254
 
The network name for a branch format is an identifier that can be used when
2255
 
referring to formats with smart server operations. See
2256
 
BranchFormat.network_name() for more detail.
2257
 
"""
2258
 
 
2259
 
 
2260
1179
# formats which have no format string are not discoverable
2261
1180
# and not independently creatable, so are not registered.
2262
 
__format5 = BzrBranchFormat5()
2263
 
__format6 = BzrBranchFormat6()
2264
 
__format7 = BzrBranchFormat7()
2265
 
__format8 = BzrBranchFormat8()
2266
 
BranchFormat.register_format(__format5)
 
1181
__default_format = BzrBranchFormat5()
 
1182
BranchFormat.register_format(__default_format)
2267
1183
BranchFormat.register_format(BranchReferenceFormat())
2268
 
BranchFormat.register_format(__format6)
2269
 
BranchFormat.register_format(__format7)
2270
 
BranchFormat.register_format(__format8)
2271
 
BranchFormat.set_default_format(__format7)
 
1184
BranchFormat.register_format(BzrBranchFormat6())
 
1185
BranchFormat.set_default_format(__default_format)
2272
1186
_legacy_formats = [BzrBranchFormat4(),
2273
 
    ]
2274
 
network_format_registry.register(
2275
 
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2276
 
 
2277
 
 
2278
 
class BranchWriteLockResult(LogicalLockResult):
2279
 
    """The result of write locking a branch.
2280
 
 
2281
 
    :ivar branch_token: The token obtained from the underlying branch lock, or
2282
 
        None.
2283
 
    :ivar unlock: A callable which will unlock the lock.
2284
 
    """
2285
 
 
2286
 
    def __init__(self, unlock, branch_token):
2287
 
        LogicalLockResult.__init__(self, unlock)
2288
 
        self.branch_token = branch_token
2289
 
 
2290
 
    def __repr__(self):
2291
 
        return "BranchWriteLockResult(%s, %s)" % (self.branch_token,
2292
 
            self.unlock)
2293
 
 
2294
 
 
2295
 
class BzrBranch(Branch, _RelockDebugMixin):
 
1187
                   ]
 
1188
 
 
1189
class BzrBranch(Branch):
2296
1190
    """A branch stored in the actual filesystem.
2297
1191
 
2298
1192
    Note that it's "local" in the context of the filesystem; it doesn't
2299
1193
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
2300
1194
    it's writable, and can be accessed via the normal filesystem API.
2301
 
 
2302
 
    :ivar _transport: Transport for file operations on this branch's
2303
 
        control files, typically pointing to the .bzr/branch directory.
2304
 
    :ivar repository: Repository for this branch.
2305
 
    :ivar base: The url of the base directory for this branch; the one
2306
 
        containing the .bzr directory.
2307
 
    :ivar name: Optional colocated branch name as it exists in the control
2308
 
        directory.
2309
1195
    """
2310
 
 
 
1196
    
2311
1197
    def __init__(self, _format=None,
2312
 
                 _control_files=None, a_bzrdir=None, name=None,
2313
 
                 _repository=None, ignore_fallbacks=False):
 
1198
                 _control_files=None, a_bzrdir=None, _repository=None):
2314
1199
        """Create new branch object at a particular location."""
 
1200
        Branch.__init__(self)
2315
1201
        if a_bzrdir is None:
2316
1202
            raise ValueError('a_bzrdir must be supplied')
2317
1203
        else:
2318
1204
            self.bzrdir = a_bzrdir
 
1205
        # self._transport used to point to the directory containing the
 
1206
        # control directory, but was not used - now it's just the transport
 
1207
        # for the branch control files.  mbp 20070212
2319
1208
        self._base = self.bzrdir.transport.clone('..').base
2320
 
        self.name = name
2321
 
        # XXX: We should be able to just do
2322
 
        #   self.base = self.bzrdir.root_transport.base
2323
 
        # but this does not quite work yet -- mbp 20080522
2324
1209
        self._format = _format
2325
1210
        if _control_files is None:
2326
1211
            raise ValueError('BzrBranch _control_files is None')
2327
1212
        self.control_files = _control_files
2328
1213
        self._transport = _control_files._transport
2329
1214
        self.repository = _repository
2330
 
        Branch.__init__(self)
2331
1215
 
2332
1216
    def __str__(self):
2333
 
        if self.name is None:
2334
 
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
2335
 
        else:
2336
 
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2337
 
                self.name)
 
1217
        return '%s(%r)' % (self.__class__.__name__, self.base)
2338
1218
 
2339
1219
    __repr__ = __str__
2340
1220
 
2344
1224
 
2345
1225
    base = property(_get_base, doc="The URL for the root of this branch.")
2346
1226
 
2347
 
    def _get_config(self):
2348
 
        return TransportConfig(self._transport, 'branch.conf')
 
1227
    def abspath(self, name):
 
1228
        """See Branch.abspath."""
 
1229
        return self.control_files._transport.abspath(name)
 
1230
 
 
1231
 
 
1232
    @deprecated_method(zero_sixteen)
 
1233
    @needs_read_lock
 
1234
    def get_root_id(self):
 
1235
        """See Branch.get_root_id."""
 
1236
        tree = self.repository.revision_tree(self.last_revision())
 
1237
        return tree.inventory.root.file_id
2349
1238
 
2350
1239
    def is_locked(self):
2351
1240
        return self.control_files.is_locked()
2352
1241
 
2353
1242
    def lock_write(self, token=None):
2354
 
        """Lock the branch for write operations.
2355
 
 
2356
 
        :param token: A token to permit reacquiring a previously held and
2357
 
            preserved lock.
2358
 
        :return: A BranchWriteLockResult.
2359
 
        """
2360
 
        if not self.is_locked():
2361
 
            self._note_lock('w')
2362
 
        # All-in-one needs to always unlock/lock.
2363
 
        repo_control = getattr(self.repository, 'control_files', None)
2364
 
        if self.control_files == repo_control or not self.is_locked():
2365
 
            self.repository._warn_if_deprecated(self)
2366
 
            self.repository.lock_write()
2367
 
            took_lock = True
2368
 
        else:
2369
 
            took_lock = False
 
1243
        repo_token = self.repository.lock_write()
2370
1244
        try:
2371
 
            return BranchWriteLockResult(self.unlock,
2372
 
                self.control_files.lock_write(token=token))
 
1245
            token = self.control_files.lock_write(token=token)
2373
1246
        except:
2374
 
            if took_lock:
2375
 
                self.repository.unlock()
 
1247
            self.repository.unlock()
2376
1248
            raise
 
1249
        return token
2377
1250
 
2378
1251
    def lock_read(self):
2379
 
        """Lock the branch for read operations.
2380
 
 
2381
 
        :return: A bzrlib.lock.LogicalLockResult.
2382
 
        """
2383
 
        if not self.is_locked():
2384
 
            self._note_lock('r')
2385
 
        # All-in-one needs to always unlock/lock.
2386
 
        repo_control = getattr(self.repository, 'control_files', None)
2387
 
        if self.control_files == repo_control or not self.is_locked():
2388
 
            self.repository._warn_if_deprecated(self)
2389
 
            self.repository.lock_read()
2390
 
            took_lock = True
2391
 
        else:
2392
 
            took_lock = False
 
1252
        self.repository.lock_read()
2393
1253
        try:
2394
1254
            self.control_files.lock_read()
2395
 
            return LogicalLockResult(self.unlock)
2396
1255
        except:
2397
 
            if took_lock:
2398
 
                self.repository.unlock()
 
1256
            self.repository.unlock()
2399
1257
            raise
2400
1258
 
2401
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2402
1259
    def unlock(self):
 
1260
        # TODO: test for failed two phase locks. This is known broken.
2403
1261
        try:
2404
1262
            self.control_files.unlock()
2405
1263
        finally:
2406
 
            # All-in-one needs to always unlock/lock.
2407
 
            repo_control = getattr(self.repository, 'control_files', None)
2408
 
            if (self.control_files == repo_control or
2409
 
                not self.control_files.is_locked()):
2410
 
                self.repository.unlock()
2411
 
            if not self.control_files.is_locked():
2412
 
                # we just released the lock
2413
 
                self._clear_cached_state()
2414
 
 
 
1264
            self.repository.unlock()
 
1265
        if not self.control_files.is_locked():
 
1266
            # we just released the lock
 
1267
            self._clear_cached_state()
 
1268
        
2415
1269
    def peek_lock_mode(self):
2416
1270
        if self.control_files._lock_count == 0:
2417
1271
            return None
2426
1280
        """See Branch.print_file."""
2427
1281
        return self.repository.print_file(file, revision_id)
2428
1282
 
 
1283
    @needs_write_lock
 
1284
    def append_revision(self, *revision_ids):
 
1285
        """See Branch.append_revision."""
 
1286
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
1287
        for revision_id in revision_ids:
 
1288
            _mod_revision.check_not_reserved_id(revision_id)
 
1289
            mutter("add {%s} to revision-history" % revision_id)
 
1290
        rev_history = self.revision_history()
 
1291
        rev_history.extend(revision_ids)
 
1292
        self.set_revision_history(rev_history)
 
1293
 
2429
1294
    def _write_revision_history(self, history):
2430
1295
        """Factored out of set_revision_history.
2431
1296
 
2432
1297
        This performs the actual writing to disk.
2433
1298
        It is intended to be called by BzrBranch5.set_revision_history."""
2434
 
        self._transport.put_bytes(
2435
 
            'revision-history', '\n'.join(history),
2436
 
            mode=self.bzrdir._get_file_mode())
 
1299
        self.control_files.put_bytes(
 
1300
            'revision-history', '\n'.join(history))
2437
1301
 
2438
1302
    @needs_write_lock
2439
1303
    def set_revision_history(self, rev_history):
2440
1304
        """See Branch.set_revision_history."""
2441
 
        if 'evil' in debug.debug_flags:
2442
 
            mutter_callsite(3, "set_revision_history scales with history.")
2443
 
        check_not_reserved_id = _mod_revision.check_not_reserved_id
2444
 
        for rev_id in rev_history:
2445
 
            check_not_reserved_id(rev_id)
2446
 
        if Branch.hooks['post_change_branch_tip']:
2447
 
            # Don't calculate the last_revision_info() if there are no hooks
2448
 
            # that will use it.
2449
 
            old_revno, old_revid = self.last_revision_info()
2450
 
        if len(rev_history) == 0:
2451
 
            revid = _mod_revision.NULL_REVISION
2452
 
        else:
2453
 
            revid = rev_history[-1]
2454
 
        self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
 
1305
        rev_history = [osutils.safe_revision_id(r) for r in rev_history]
2455
1306
        self._write_revision_history(rev_history)
2456
 
        self._clear_cached_state()
2457
1307
        self._cache_revision_history(rev_history)
2458
1308
        for hook in Branch.hooks['set_rh']:
2459
1309
            hook(self, rev_history)
2460
 
        if Branch.hooks['post_change_branch_tip']:
2461
 
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2462
 
 
2463
 
    def _synchronize_history(self, destination, revision_id):
2464
 
        """Synchronize last revision and revision history between branches.
2465
 
 
2466
 
        This version is most efficient when the destination is also a
2467
 
        BzrBranch5, but works for BzrBranch6 as long as the revision
2468
 
        history is the true lefthand parent history, and all of the revisions
2469
 
        are in the destination's repository.  If not, set_revision_history
2470
 
        will fail.
2471
 
 
2472
 
        :param destination: The branch to copy the history into
2473
 
        :param revision_id: The revision-id to truncate history at.  May
2474
 
          be None to copy complete history.
2475
 
        """
2476
 
        if not isinstance(destination._format, BzrBranchFormat5):
2477
 
            super(BzrBranch, self)._synchronize_history(
2478
 
                destination, revision_id)
2479
 
            return
2480
 
        if revision_id == _mod_revision.NULL_REVISION:
2481
 
            new_history = []
2482
 
        else:
2483
 
            new_history = self.revision_history()
2484
 
        if revision_id is not None and new_history != []:
2485
 
            try:
2486
 
                new_history = new_history[:new_history.index(revision_id) + 1]
2487
 
            except ValueError:
2488
 
                rev = self.repository.get_revision(revision_id)
2489
 
                new_history = rev.get_history(self.repository)[1:]
2490
 
        destination.set_revision_history(new_history)
2491
1310
 
2492
1311
    @needs_write_lock
2493
1312
    def set_last_revision_info(self, revno, revision_id):
2494
 
        """Set the last revision of this branch.
2495
 
 
2496
 
        The caller is responsible for checking that the revno is correct
2497
 
        for this revision id.
2498
 
 
2499
 
        It may be possible to set the branch last revision to an id not
2500
 
        present in the repository.  However, branches can also be
2501
 
        configured to check constraints on history, in which case this may not
2502
 
        be permitted.
2503
 
        """
2504
 
        revision_id = _mod_revision.ensure_null(revision_id)
2505
 
        # this old format stores the full history, but this api doesn't
2506
 
        # provide it, so we must generate, and might as well check it's
2507
 
        # correct
 
1313
        revision_id = osutils.safe_revision_id(revision_id)
2508
1314
        history = self._lefthand_history(revision_id)
2509
 
        if len(history) != revno:
2510
 
            raise AssertionError('%d != %d' % (len(history), revno))
 
1315
        assert len(history) == revno, '%d != %d' % (len(history), revno)
2511
1316
        self.set_revision_history(history)
2512
1317
 
2513
1318
    def _gen_revision_history(self):
2514
 
        history = self._transport.get_bytes('revision-history').split('\n')
 
1319
        history = self.control_files.get('revision-history').read().split('\n')
2515
1320
        if history[-1:] == ['']:
2516
1321
            # There shouldn't be a trailing newline, but just in case.
2517
1322
            history.pop()
2518
1323
        return history
2519
1324
 
 
1325
    def _lefthand_history(self, revision_id, last_rev=None,
 
1326
                          other_branch=None):
 
1327
        # stop_revision must be a descendant of last_revision
 
1328
        stop_graph = self.repository.get_revision_graph(revision_id)
 
1329
        if last_rev is not None and last_rev not in stop_graph:
 
1330
            # our previous tip is not merged into stop_revision
 
1331
            raise errors.DivergedBranches(self, other_branch)
 
1332
        # make a new revision history from the graph
 
1333
        current_rev_id = revision_id
 
1334
        new_history = []
 
1335
        while current_rev_id not in (None, _mod_revision.NULL_REVISION):
 
1336
            new_history.append(current_rev_id)
 
1337
            current_rev_id_parents = stop_graph[current_rev_id]
 
1338
            try:
 
1339
                current_rev_id = current_rev_id_parents[0]
 
1340
            except IndexError:
 
1341
                current_rev_id = None
 
1342
        new_history.reverse()
 
1343
        return new_history
 
1344
 
2520
1345
    @needs_write_lock
2521
1346
    def generate_revision_history(self, revision_id, last_rev=None,
2522
1347
        other_branch=None):
2528
1353
        :param other_branch: The other branch that DivergedBranches should
2529
1354
            raise with respect to.
2530
1355
        """
 
1356
        revision_id = osutils.safe_revision_id(revision_id)
2531
1357
        self.set_revision_history(self._lefthand_history(revision_id,
2532
1358
            last_rev, other_branch))
2533
1359
 
 
1360
    @needs_write_lock
 
1361
    def update_revisions(self, other, stop_revision=None):
 
1362
        """See Branch.update_revisions."""
 
1363
        other.lock_read()
 
1364
        try:
 
1365
            if stop_revision is None:
 
1366
                stop_revision = other.last_revision()
 
1367
                if stop_revision is None:
 
1368
                    # if there are no commits, we're done.
 
1369
                    return
 
1370
            else:
 
1371
                stop_revision = osutils.safe_revision_id(stop_revision)
 
1372
            # whats the current last revision, before we fetch [and change it
 
1373
            # possibly]
 
1374
            last_rev = self.last_revision()
 
1375
            # we fetch here regardless of whether we need to so that we pickup
 
1376
            # filled in ghosts.
 
1377
            self.fetch(other, stop_revision)
 
1378
            my_ancestry = self.repository.get_ancestry(last_rev)
 
1379
            if stop_revision in my_ancestry:
 
1380
                # last_revision is a descendant of stop_revision
 
1381
                return
 
1382
            self.generate_revision_history(stop_revision, last_rev=last_rev,
 
1383
                other_branch=other)
 
1384
        finally:
 
1385
            other.unlock()
 
1386
 
2534
1387
    def basis_tree(self):
2535
1388
        """See Branch.basis_tree."""
2536
1389
        return self.repository.revision_tree(self.last_revision())
2537
1390
 
 
1391
    @deprecated_method(zero_eight)
 
1392
    def working_tree(self):
 
1393
        """Create a Working tree object for this branch."""
 
1394
 
 
1395
        from bzrlib.transport.local import LocalTransport
 
1396
        if (self.base.find('://') != -1 or 
 
1397
            not isinstance(self._transport, LocalTransport)):
 
1398
            raise NoWorkingTree(self.base)
 
1399
        return self.bzrdir.open_workingtree()
 
1400
 
 
1401
    @needs_write_lock
 
1402
    def pull(self, source, overwrite=False, stop_revision=None,
 
1403
        _hook_master=None, _run_hooks=True):
 
1404
        """See Branch.pull.
 
1405
 
 
1406
        :param _hook_master: Private parameter - set the branch to 
 
1407
            be supplied as the master to push hooks.
 
1408
        :param _run_hooks: Private parameter - allow disabling of
 
1409
            hooks, used when pushing to a master branch.
 
1410
        """
 
1411
        result = PullResult()
 
1412
        result.source_branch = source
 
1413
        result.target_branch = self
 
1414
        source.lock_read()
 
1415
        try:
 
1416
            result.old_revno, result.old_revid = self.last_revision_info()
 
1417
            try:
 
1418
                self.update_revisions(source, stop_revision)
 
1419
            except DivergedBranches:
 
1420
                if not overwrite:
 
1421
                    raise
 
1422
            if overwrite:
 
1423
                if stop_revision is None:
 
1424
                    stop_revision = source.last_revision()
 
1425
                self.generate_revision_history(stop_revision)
 
1426
            result.tag_conflicts = source.tags.merge_to(self.tags)
 
1427
            result.new_revno, result.new_revid = self.last_revision_info()
 
1428
            if _hook_master:
 
1429
                result.master_branch = _hook_master
 
1430
                result.local_branch = self
 
1431
            else:
 
1432
                result.master_branch = self
 
1433
                result.local_branch = None
 
1434
            if _run_hooks:
 
1435
                for hook in Branch.hooks['post_pull']:
 
1436
                    hook(result)
 
1437
        finally:
 
1438
            source.unlock()
 
1439
        return result
 
1440
 
2538
1441
    def _get_parent_location(self):
2539
1442
        _locs = ['parent', 'pull', 'x-pull']
2540
1443
        for l in _locs:
2541
1444
            try:
2542
 
                return self._transport.get_bytes(l).strip('\n')
2543
 
            except errors.NoSuchFile:
 
1445
                return self.control_files.get(l).read().strip('\n')
 
1446
            except NoSuchFile:
2544
1447
                pass
2545
1448
        return None
2546
1449
 
2547
 
    def _basic_push(self, target, overwrite, stop_revision):
2548
 
        """Basic implementation of push without bound branches or hooks.
2549
 
 
2550
 
        Must be called with source read locked and target write locked.
 
1450
    @needs_read_lock
 
1451
    def push(self, target, overwrite=False, stop_revision=None,
 
1452
        _hook_master=None, _run_hooks=True):
 
1453
        """See Branch.push.
 
1454
        
 
1455
        :param _hook_master: Private parameter - set the branch to 
 
1456
            be supplied as the master to push hooks.
 
1457
        :param _run_hooks: Private parameter - allow disabling of
 
1458
            hooks, used when pushing to a master branch.
2551
1459
        """
2552
 
        result = BranchPushResult()
 
1460
        result = PushResult()
2553
1461
        result.source_branch = self
2554
1462
        result.target_branch = target
2555
 
        result.old_revno, result.old_revid = target.last_revision_info()
2556
 
        self.update_references(target)
2557
 
        if result.old_revid != self.last_revision():
2558
 
            # We assume that during 'push' this repository is closer than
2559
 
            # the target.
2560
 
            graph = self.repository.get_graph(target.repository)
2561
 
            target.update_revisions(self, stop_revision,
2562
 
                overwrite=overwrite, graph=graph)
2563
 
        if self._push_should_merge_tags():
2564
 
            result.tag_conflicts = self.tags.merge_to(target.tags,
2565
 
                overwrite)
2566
 
        result.new_revno, result.new_revid = target.last_revision_info()
 
1463
        target.lock_write()
 
1464
        try:
 
1465
            result.old_revno, result.old_revid = target.last_revision_info()
 
1466
            try:
 
1467
                target.update_revisions(self, stop_revision)
 
1468
            except DivergedBranches:
 
1469
                if not overwrite:
 
1470
                    raise
 
1471
            if overwrite:
 
1472
                target.set_revision_history(self.revision_history())
 
1473
            result.tag_conflicts = self.tags.merge_to(target.tags)
 
1474
            result.new_revno, result.new_revid = target.last_revision_info()
 
1475
            if _hook_master:
 
1476
                result.master_branch = _hook_master
 
1477
                result.local_branch = target
 
1478
            else:
 
1479
                result.master_branch = target
 
1480
                result.local_branch = None
 
1481
            if _run_hooks:
 
1482
                for hook in Branch.hooks['post_push']:
 
1483
                    hook(result)
 
1484
        finally:
 
1485
            target.unlock()
2567
1486
        return result
2568
1487
 
2569
 
    def get_stacked_on_url(self):
2570
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
1488
    def get_parent(self):
 
1489
        """See Branch.get_parent."""
 
1490
 
 
1491
        assert self.base[-1] == '/'
 
1492
        parent = self._get_parent_location()
 
1493
        if parent is None:
 
1494
            return parent
 
1495
        # This is an old-format absolute path to a local branch
 
1496
        # turn it into a url
 
1497
        if parent.startswith('/'):
 
1498
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
 
1499
        try:
 
1500
            return urlutils.join(self.base[:-1], parent)
 
1501
        except errors.InvalidURLJoin, e:
 
1502
            raise errors.InaccessibleParent(parent, self.base)
 
1503
 
 
1504
    def get_push_location(self):
 
1505
        """See Branch.get_push_location."""
 
1506
        push_loc = self.get_config().get_user_option('push_location')
 
1507
        return push_loc
2571
1508
 
2572
1509
    def set_push_location(self, location):
2573
1510
        """See Branch.set_push_location."""
2575
1512
            'push_location', location,
2576
1513
            store=_mod_config.STORE_LOCATION_NORECURSE)
2577
1514
 
 
1515
    @needs_write_lock
 
1516
    def set_parent(self, url):
 
1517
        """See Branch.set_parent."""
 
1518
        # TODO: Maybe delete old location files?
 
1519
        # URLs should never be unicode, even on the local fs,
 
1520
        # FIXUP this and get_parent in a future branch format bump:
 
1521
        # read and rewrite the file, and have the new format code read
 
1522
        # using .get not .get_utf8. RBC 20060125
 
1523
        if url is not None:
 
1524
            if isinstance(url, unicode):
 
1525
                try: 
 
1526
                    url = url.encode('ascii')
 
1527
                except UnicodeEncodeError:
 
1528
                    raise bzrlib.errors.InvalidURL(url,
 
1529
                        "Urls must be 7-bit ascii, "
 
1530
                        "use bzrlib.urlutils.escape")
 
1531
            url = urlutils.relative_url(self.base, url)
 
1532
        self._set_parent_location(url)
 
1533
 
2578
1534
    def _set_parent_location(self, url):
2579
1535
        if url is None:
2580
 
            self._transport.delete('parent')
 
1536
            self.control_files._transport.delete('parent')
2581
1537
        else:
2582
 
            self._transport.put_bytes('parent', url + '\n',
2583
 
                mode=self.bzrdir._get_file_mode())
 
1538
            assert isinstance(url, str)
 
1539
            self.control_files.put_bytes('parent', url + '\n')
 
1540
 
 
1541
    @deprecated_function(zero_nine)
 
1542
    def tree_config(self):
 
1543
        """DEPRECATED; call get_config instead.  
 
1544
        TreeConfig has become part of BranchConfig."""
 
1545
        return TreeConfig(self)
2584
1546
 
2585
1547
 
2586
1548
class BzrBranch5(BzrBranch):
2587
 
    """A format 5 branch. This supports new features over plain branches.
 
1549
    """A format 5 branch. This supports new features over plan branches.
2588
1550
 
2589
1551
    It has support for a master_branch which is the data for bound branches.
2590
1552
    """
2591
1553
 
 
1554
    def __init__(self,
 
1555
                 _format,
 
1556
                 _control_files,
 
1557
                 a_bzrdir,
 
1558
                 _repository):
 
1559
        super(BzrBranch5, self).__init__(_format=_format,
 
1560
                                         _control_files=_control_files,
 
1561
                                         a_bzrdir=a_bzrdir,
 
1562
                                         _repository=_repository)
 
1563
        
 
1564
    @needs_write_lock
 
1565
    def pull(self, source, overwrite=False, stop_revision=None,
 
1566
        _run_hooks=True):
 
1567
        """Extends branch.pull to be bound branch aware.
 
1568
        
 
1569
        :param _run_hooks: Private parameter used to force hook running
 
1570
            off during bound branch double-pushing.
 
1571
        """
 
1572
        bound_location = self.get_bound_location()
 
1573
        master_branch = None
 
1574
        if bound_location and source.base != bound_location:
 
1575
            # not pulling from master, so we need to update master.
 
1576
            master_branch = self.get_master_branch()
 
1577
            master_branch.lock_write()
 
1578
        try:
 
1579
            if master_branch:
 
1580
                # pull from source into master.
 
1581
                master_branch.pull(source, overwrite, stop_revision,
 
1582
                    _run_hooks=False)
 
1583
            return super(BzrBranch5, self).pull(source, overwrite,
 
1584
                stop_revision, _hook_master=master_branch,
 
1585
                _run_hooks=_run_hooks)
 
1586
        finally:
 
1587
            if master_branch:
 
1588
                master_branch.unlock()
 
1589
 
 
1590
    @needs_read_lock
 
1591
    def push(self, target, overwrite=False, stop_revision=None):
 
1592
        """Updates branch.push to be bound branch aware."""
 
1593
        bound_location = target.get_bound_location()
 
1594
        master_branch = None
 
1595
        if bound_location and target.base != bound_location:
 
1596
            # not pushing to master, so we need to update master.
 
1597
            master_branch = target.get_master_branch()
 
1598
            master_branch.lock_write()
 
1599
        try:
 
1600
            if master_branch:
 
1601
                # push into the master from this branch.
 
1602
                super(BzrBranch5, self).push(master_branch, overwrite,
 
1603
                    stop_revision, _run_hooks=False)
 
1604
            # and push into the target branch from this. Note that we push from
 
1605
            # this branch again, because its considered the highest bandwidth
 
1606
            # repository.
 
1607
            return super(BzrBranch5, self).push(target, overwrite,
 
1608
                stop_revision, _hook_master=master_branch)
 
1609
        finally:
 
1610
            if master_branch:
 
1611
                master_branch.unlock()
 
1612
 
2592
1613
    def get_bound_location(self):
2593
1614
        try:
2594
 
            return self._transport.get_bytes('bound')[:-1]
 
1615
            return self.control_files.get_utf8('bound').read()[:-1]
2595
1616
        except errors.NoSuchFile:
2596
1617
            return None
2597
1618
 
2598
1619
    @needs_read_lock
2599
 
    def get_master_branch(self, possible_transports=None):
 
1620
    def get_master_branch(self):
2600
1621
        """Return the branch we are bound to.
2601
 
 
 
1622
        
2602
1623
        :return: Either a Branch, or None
2603
1624
 
2604
1625
        This could memoise the branch, but if thats done
2610
1631
        if not bound_loc:
2611
1632
            return None
2612
1633
        try:
2613
 
            return Branch.open(bound_loc,
2614
 
                               possible_transports=possible_transports)
 
1634
            return Branch.open(bound_loc)
2615
1635
        except (errors.NotBranchError, errors.ConnectionError), e:
2616
1636
            raise errors.BoundBranchConnectionFailure(
2617
1637
                    self, bound_loc, e)
2623
1643
        :param location: URL to the target branch
2624
1644
        """
2625
1645
        if location:
2626
 
            self._transport.put_bytes('bound', location+'\n',
2627
 
                mode=self.bzrdir._get_file_mode())
 
1646
            self.control_files.put_utf8('bound', location+'\n')
2628
1647
        else:
2629
1648
            try:
2630
 
                self._transport.delete('bound')
2631
 
            except errors.NoSuchFile:
 
1649
                self.control_files._transport.delete('bound')
 
1650
            except NoSuchFile:
2632
1651
                return False
2633
1652
            return True
2634
1653
 
2640
1659
        check for divergence to raise an error when the branches are not
2641
1660
        either the same, or one a prefix of the other. That behaviour may not
2642
1661
        be useful, so that check may be removed in future.
2643
 
 
 
1662
        
2644
1663
        :param other: The branch to bind to
2645
1664
        :type other: Branch
2646
1665
        """
2656
1675
        # last_rev is not in the other_last_rev history, AND
2657
1676
        # other_last_rev is not in our history, and do it without pulling
2658
1677
        # history around
 
1678
        last_rev = self.last_revision()
 
1679
        if last_rev is not None:
 
1680
            other.lock_read()
 
1681
            try:
 
1682
                other_last_rev = other.last_revision()
 
1683
                if other_last_rev is not None:
 
1684
                    # neither branch is new, we have to do some work to
 
1685
                    # ascertain diversion.
 
1686
                    remote_graph = other.repository.get_revision_graph(
 
1687
                        other_last_rev)
 
1688
                    local_graph = self.repository.get_revision_graph(last_rev)
 
1689
                    if (last_rev not in remote_graph and
 
1690
                        other_last_rev not in local_graph):
 
1691
                        raise errors.DivergedBranches(self, other)
 
1692
            finally:
 
1693
                other.unlock()
2659
1694
        self.set_bound_location(other.base)
2660
1695
 
2661
1696
    @needs_write_lock
2664
1699
        return self.set_bound_location(None)
2665
1700
 
2666
1701
    @needs_write_lock
2667
 
    def update(self, possible_transports=None):
2668
 
        """Synchronise this branch with the master branch if any.
 
1702
    def update(self):
 
1703
        """Synchronise this branch with the master branch if any. 
2669
1704
 
2670
1705
        :return: None or the last_revision that was pivoted out during the
2671
1706
                 update.
2672
1707
        """
2673
 
        master = self.get_master_branch(possible_transports)
 
1708
        master = self.get_master_branch()
2674
1709
        if master is not None:
2675
 
            old_tip = _mod_revision.ensure_null(self.last_revision())
 
1710
            old_tip = self.last_revision()
2676
1711
            self.pull(master, overwrite=True)
2677
 
            if self.repository.get_graph().is_ancestor(old_tip,
2678
 
                _mod_revision.ensure_null(self.last_revision())):
 
1712
            if old_tip in self.repository.get_ancestry(self.last_revision()):
2679
1713
                return None
2680
1714
            return old_tip
2681
1715
        return None
2682
1716
 
2683
1717
 
2684
 
class BzrBranch8(BzrBranch5):
2685
 
    """A branch that stores tree-reference locations."""
2686
 
 
2687
 
    def _open_hook(self):
2688
 
        if self._ignore_fallbacks:
2689
 
            return
 
1718
class BzrBranchExperimental(BzrBranch5):
 
1719
    """Bzr experimental branch format
 
1720
 
 
1721
    This format has:
 
1722
     - a revision-history file.
 
1723
     - a format string
 
1724
     - a lock dir guarding the branch itself
 
1725
     - all of this stored in a branch/ subdirectory
 
1726
     - works with shared repositories.
 
1727
     - a tag dictionary in the branch
 
1728
 
 
1729
    This format is new in bzr 0.15, but shouldn't be used for real data, 
 
1730
    only for testing.
 
1731
 
 
1732
    This class acts as it's own BranchFormat.
 
1733
    """
 
1734
 
 
1735
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1736
 
 
1737
    @classmethod
 
1738
    def get_format_string(cls):
 
1739
        """See BranchFormat.get_format_string()."""
 
1740
        return "Bazaar-NG branch format experimental\n"
 
1741
 
 
1742
    @classmethod
 
1743
    def get_format_description(cls):
 
1744
        """See BranchFormat.get_format_description()."""
 
1745
        return "Experimental branch format"
 
1746
 
 
1747
    @classmethod
 
1748
    def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
 
1749
            lock_class):
 
1750
        branch_transport = a_bzrdir.get_branch_transport(cls)
 
1751
        control_files = lockable_files.LockableFiles(branch_transport,
 
1752
            lock_filename, lock_class)
 
1753
        control_files.create_lock()
 
1754
        control_files.lock_write()
2690
1755
        try:
2691
 
            url = self.get_stacked_on_url()
2692
 
        except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2693
 
            errors.UnstackableBranchFormat):
2694
 
            pass
2695
 
        else:
2696
 
            for hook in Branch.hooks['transform_fallback_location']:
2697
 
                url = hook(self, url)
2698
 
                if url is None:
2699
 
                    hook_name = Branch.hooks.get_hook_name(hook)
2700
 
                    raise AssertionError(
2701
 
                        "'transform_fallback_location' hook %s returned "
2702
 
                        "None, not a URL." % hook_name)
2703
 
            self._activate_fallback_location(url)
2704
 
 
2705
 
    def __init__(self, *args, **kwargs):
2706
 
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2707
 
        super(BzrBranch8, self).__init__(*args, **kwargs)
2708
 
        self._last_revision_info_cache = None
2709
 
        self._reference_info = None
2710
 
 
2711
 
    def _clear_cached_state(self):
2712
 
        super(BzrBranch8, self)._clear_cached_state()
2713
 
        self._last_revision_info_cache = None
2714
 
        self._reference_info = None
2715
 
 
2716
 
    def _last_revision_info(self):
2717
 
        revision_string = self._transport.get_bytes('last-revision')
 
1756
            for filename, content in utf8_files:
 
1757
                control_files.put_utf8(filename, content)
 
1758
        finally:
 
1759
            control_files.unlock()
 
1760
        
 
1761
    @classmethod
 
1762
    def initialize(cls, a_bzrdir):
 
1763
        """Create a branch of this format in a_bzrdir."""
 
1764
        utf8_files = [('format', cls.get_format_string()),
 
1765
                      ('revision-history', ''),
 
1766
                      ('branch-name', ''),
 
1767
                      ('tags', ''),
 
1768
                      ]
 
1769
        cls._initialize_control_files(a_bzrdir, utf8_files,
 
1770
            'lock', lockdir.LockDir)
 
1771
        return cls.open(a_bzrdir, _found=True)
 
1772
 
 
1773
    @classmethod
 
1774
    def open(cls, a_bzrdir, _found=False):
 
1775
        """Return the branch object for a_bzrdir
 
1776
 
 
1777
        _found is a private parameter, do not use it. It is used to indicate
 
1778
               if format probing has already be done.
 
1779
        """
 
1780
        if not _found:
 
1781
            format = BranchFormat.find_format(a_bzrdir)
 
1782
            assert format.__class__ == cls
 
1783
        transport = a_bzrdir.get_branch_transport(None)
 
1784
        control_files = lockable_files.LockableFiles(transport, 'lock',
 
1785
                                                     lockdir.LockDir)
 
1786
        return cls(_format=cls,
 
1787
            _control_files=control_files,
 
1788
            a_bzrdir=a_bzrdir,
 
1789
            _repository=a_bzrdir.find_repository())
 
1790
 
 
1791
    @classmethod
 
1792
    def is_supported(cls):
 
1793
        return True
 
1794
 
 
1795
    def _make_tags(self):
 
1796
        return BasicTags(self)
 
1797
 
 
1798
    @classmethod
 
1799
    def supports_tags(cls):
 
1800
        return True
 
1801
 
 
1802
 
 
1803
BranchFormat.register_format(BzrBranchExperimental)
 
1804
 
 
1805
 
 
1806
class BzrBranch6(BzrBranch5):
 
1807
 
 
1808
    @needs_read_lock
 
1809
    def last_revision_info(self):
 
1810
        revision_string = self.control_files.get('last-revision').read()
2718
1811
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2719
1812
        revision_id = cache_utf8.get_cached_utf8(revision_id)
2720
1813
        revno = int(revno)
2721
1814
        return revno, revision_id
2722
1815
 
 
1816
    def last_revision(self):
 
1817
        """Return last revision id, or None"""
 
1818
        revision_id = self.last_revision_info()[1]
 
1819
        if revision_id == _mod_revision.NULL_REVISION:
 
1820
            revision_id = None
 
1821
        return revision_id
 
1822
 
2723
1823
    def _write_last_revision_info(self, revno, revision_id):
2724
1824
        """Simply write out the revision id, with no checks.
2725
1825
 
2729
1829
        Intended to be called by set_last_revision_info and
2730
1830
        _write_revision_history.
2731
1831
        """
2732
 
        revision_id = _mod_revision.ensure_null(revision_id)
 
1832
        if revision_id is None:
 
1833
            revision_id = 'null:'
2733
1834
        out_string = '%d %s\n' % (revno, revision_id)
2734
 
        self._transport.put_bytes('last-revision', out_string,
2735
 
            mode=self.bzrdir._get_file_mode())
 
1835
        self.control_files.put_bytes('last-revision', out_string)
2736
1836
 
2737
1837
    @needs_write_lock
2738
1838
    def set_last_revision_info(self, revno, revision_id):
2739
 
        revision_id = _mod_revision.ensure_null(revision_id)
2740
 
        old_revno, old_revid = self.last_revision_info()
 
1839
        revision_id = osutils.safe_revision_id(revision_id)
2741
1840
        if self._get_append_revisions_only():
2742
1841
            self._check_history_violation(revision_id)
2743
 
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2744
1842
        self._write_last_revision_info(revno, revision_id)
2745
1843
        self._clear_cached_state()
2746
 
        self._last_revision_info_cache = revno, revision_id
2747
 
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2748
 
 
2749
 
    def _synchronize_history(self, destination, revision_id):
2750
 
        """Synchronize last revision and revision history between branches.
2751
 
 
2752
 
        :see: Branch._synchronize_history
2753
 
        """
2754
 
        # XXX: The base Branch has a fast implementation of this method based
2755
 
        # on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2756
 
        # that uses set_revision_history.  This class inherits from BzrBranch5,
2757
 
        # but wants the fast implementation, so it calls
2758
 
        # Branch._synchronize_history directly.
2759
 
        Branch._synchronize_history(self, destination, revision_id)
2760
1844
 
2761
1845
    def _check_history_violation(self, revision_id):
2762
 
        last_revision = _mod_revision.ensure_null(self.last_revision())
2763
 
        if _mod_revision.is_null(last_revision):
 
1846
        last_revision = self.last_revision()
 
1847
        if last_revision is None:
2764
1848
            return
2765
1849
        if last_revision not in self._lefthand_history(revision_id):
2766
 
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
 
1850
            raise errors.AppendRevisionsOnlyViolation(self.base)
2767
1851
 
2768
1852
    def _gen_revision_history(self):
2769
1853
        """Generate the revision history from last revision
2770
1854
        """
2771
 
        last_revno, last_revision = self.last_revision_info()
2772
 
        self._extend_partial_history(stop_index=last_revno-1)
2773
 
        return list(reversed(self._partial_revision_history_cache))
 
1855
        history = list(self.repository.iter_reverse_revision_history(
 
1856
            self.last_revision()))
 
1857
        history.reverse()
 
1858
        return history
2774
1859
 
2775
1860
    def _write_revision_history(self, history):
2776
1861
        """Factored out of set_revision_history.
2789
1874
        self._write_last_revision_info(len(history), last_revision)
2790
1875
 
2791
1876
    @needs_write_lock
 
1877
    def append_revision(self, *revision_ids):
 
1878
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
1879
        if len(revision_ids) == 0:
 
1880
            return
 
1881
        prev_revno, prev_revision = self.last_revision_info()
 
1882
        for revision in self.repository.get_revisions(revision_ids):
 
1883
            if prev_revision == _mod_revision.NULL_REVISION:
 
1884
                if revision.parent_ids != []:
 
1885
                    raise errors.NotLeftParentDescendant(self, prev_revision,
 
1886
                                                         revision.revision_id)
 
1887
            else:
 
1888
                if revision.parent_ids[0] != prev_revision:
 
1889
                    raise errors.NotLeftParentDescendant(self, prev_revision,
 
1890
                                                         revision.revision_id)
 
1891
            prev_revision = revision.revision_id
 
1892
        self.set_last_revision_info(prev_revno + len(revision_ids),
 
1893
                                    revision_ids[-1])
 
1894
 
 
1895
    @needs_write_lock
2792
1896
    def _set_parent_location(self, url):
2793
1897
        """Set the parent branch"""
2794
1898
        self._set_config_location('parent_location', url, make_relative=True)
2798
1902
        """Set the parent branch"""
2799
1903
        return self._get_config_location('parent_location')
2800
1904
 
2801
 
    @needs_write_lock
2802
 
    def _set_all_reference_info(self, info_dict):
2803
 
        """Replace all reference info stored in a branch.
2804
 
 
2805
 
        :param info_dict: A dict of {file_id: (tree_path, branch_location)}
2806
 
        """
2807
 
        s = StringIO()
2808
 
        writer = rio.RioWriter(s)
2809
 
        for key, (tree_path, branch_location) in info_dict.iteritems():
2810
 
            stanza = rio.Stanza(file_id=key, tree_path=tree_path,
2811
 
                                branch_location=branch_location)
2812
 
            writer.write_stanza(stanza)
2813
 
        self._transport.put_bytes('references', s.getvalue())
2814
 
        self._reference_info = info_dict
2815
 
 
2816
 
    @needs_read_lock
2817
 
    def _get_all_reference_info(self):
2818
 
        """Return all the reference info stored in a branch.
2819
 
 
2820
 
        :return: A dict of {file_id: (tree_path, branch_location)}
2821
 
        """
2822
 
        if self._reference_info is not None:
2823
 
            return self._reference_info
2824
 
        rio_file = self._transport.get('references')
2825
 
        try:
2826
 
            stanzas = rio.read_stanzas(rio_file)
2827
 
            info_dict = dict((s['file_id'], (s['tree_path'],
2828
 
                             s['branch_location'])) for s in stanzas)
2829
 
        finally:
2830
 
            rio_file.close()
2831
 
        self._reference_info = info_dict
2832
 
        return info_dict
2833
 
 
2834
 
    def set_reference_info(self, file_id, tree_path, branch_location):
2835
 
        """Set the branch location to use for a tree reference.
2836
 
 
2837
 
        :param file_id: The file-id of the tree reference.
2838
 
        :param tree_path: The path of the tree reference in the tree.
2839
 
        :param branch_location: The location of the branch to retrieve tree
2840
 
            references from.
2841
 
        """
2842
 
        info_dict = self._get_all_reference_info()
2843
 
        info_dict[file_id] = (tree_path, branch_location)
2844
 
        if None in (tree_path, branch_location):
2845
 
            if tree_path is not None:
2846
 
                raise ValueError('tree_path must be None when branch_location'
2847
 
                                 ' is None.')
2848
 
            if branch_location is not None:
2849
 
                raise ValueError('branch_location must be None when tree_path'
2850
 
                                 ' is None.')
2851
 
            del info_dict[file_id]
2852
 
        self._set_all_reference_info(info_dict)
2853
 
 
2854
 
    def get_reference_info(self, file_id):
2855
 
        """Get the tree_path and branch_location for a tree reference.
2856
 
 
2857
 
        :return: a tuple of (tree_path, branch_location)
2858
 
        """
2859
 
        return self._get_all_reference_info().get(file_id, (None, None))
2860
 
 
2861
 
    def reference_parent(self, file_id, path, possible_transports=None):
2862
 
        """Return the parent branch for a tree-reference file_id.
2863
 
 
2864
 
        :param file_id: The file_id of the tree reference
2865
 
        :param path: The path of the file_id in the tree
2866
 
        :return: A branch associated with the file_id
2867
 
        """
2868
 
        branch_location = self.get_reference_info(file_id)[1]
2869
 
        if branch_location is None:
2870
 
            return Branch.reference_parent(self, file_id, path,
2871
 
                                           possible_transports)
2872
 
        branch_location = urlutils.join(self.user_url, branch_location)
2873
 
        return Branch.open(branch_location,
2874
 
                           possible_transports=possible_transports)
2875
 
 
2876
1905
    def set_push_location(self, location):
2877
1906
        """See Branch.set_push_location."""
2878
1907
        self._set_config_location('push_location', location)
2885
1914
            if config.get_user_option('bound') != 'True':
2886
1915
                return False
2887
1916
            else:
2888
 
                config.set_user_option('bound', 'False', warn_masked=True)
 
1917
                config.set_user_option('bound', 'False')
2889
1918
                return True
2890
1919
        else:
2891
1920
            self._set_config_location('bound_location', location,
2892
1921
                                      config=config)
2893
 
            config.set_user_option('bound', 'True', warn_masked=True)
 
1922
            config.set_user_option('bound', 'True')
2894
1923
        return True
2895
1924
 
2896
1925
    def _get_bound_location(self, bound):
2911
1940
        """See Branch.get_old_bound_location"""
2912
1941
        return self._get_bound_location(False)
2913
1942
 
2914
 
    def get_stacked_on_url(self):
2915
 
        # you can always ask for the URL; but you might not be able to use it
2916
 
        # if the repo can't support stacking.
2917
 
        ## self._check_stackable_repo()
2918
 
        stacked_url = self._get_config_location('stacked_on_location')
2919
 
        if stacked_url is None:
2920
 
            raise errors.NotStacked(self)
2921
 
        return stacked_url
 
1943
    def set_append_revisions_only(self, enabled):
 
1944
        if enabled:
 
1945
            value = 'True'
 
1946
        else:
 
1947
            value = 'False'
 
1948
        self.get_config().set_user_option('append_revisions_only', value)
2922
1949
 
2923
1950
    def _get_append_revisions_only(self):
2924
 
        return self.get_config(
2925
 
            ).get_user_option_as_bool('append_revisions_only')
2926
 
 
2927
 
    @needs_write_lock
2928
 
    def generate_revision_history(self, revision_id, last_rev=None,
2929
 
                                  other_branch=None):
2930
 
        """See BzrBranch5.generate_revision_history"""
2931
 
        history = self._lefthand_history(revision_id, last_rev, other_branch)
2932
 
        revno = len(history)
2933
 
        self.set_last_revision_info(revno, revision_id)
2934
 
 
2935
 
    @needs_read_lock
2936
 
    def get_rev_id(self, revno, history=None):
2937
 
        """Find the revision id of the specified revno."""
2938
 
        if revno == 0:
2939
 
            return _mod_revision.NULL_REVISION
2940
 
 
2941
 
        last_revno, last_revision_id = self.last_revision_info()
2942
 
        if revno <= 0 or revno > last_revno:
2943
 
            raise errors.NoSuchRevision(self, revno)
2944
 
 
2945
 
        if history is not None:
2946
 
            return history[revno - 1]
2947
 
 
2948
 
        index = last_revno - revno
2949
 
        if len(self._partial_revision_history_cache) <= index:
2950
 
            self._extend_partial_history(stop_index=index)
2951
 
        if len(self._partial_revision_history_cache) > index:
2952
 
            return self._partial_revision_history_cache[index]
 
1951
        value = self.get_config().get_user_option('append_revisions_only')
 
1952
        return value == 'True'
 
1953
 
 
1954
    def _synchronize_history(self, destination, revision_id):
 
1955
        """Synchronize last revision and revision history between branches.
 
1956
 
 
1957
        This version is most efficient when the destination is also a
 
1958
        BzrBranch6, but works for BzrBranch5, as long as the destination's
 
1959
        repository contains all the lefthand ancestors of the intended
 
1960
        last_revision.  If not, set_last_revision_info will fail.
 
1961
 
 
1962
        :param destination: The branch to copy the history into
 
1963
        :param revision_id: The revision-id to truncate history at.  May
 
1964
          be None to copy complete history.
 
1965
        """
 
1966
        if revision_id is None:
 
1967
            revno, revision_id = self.last_revision_info()
2953
1968
        else:
2954
 
            raise errors.NoSuchRevision(self, revno)
2955
 
 
2956
 
    @needs_read_lock
2957
 
    def revision_id_to_revno(self, revision_id):
2958
 
        """Given a revision id, return its revno"""
2959
 
        if _mod_revision.is_null(revision_id):
2960
 
            return 0
2961
 
        try:
2962
 
            index = self._partial_revision_history_cache.index(revision_id)
2963
 
        except ValueError:
2964
 
            self._extend_partial_history(stop_revision=revision_id)
2965
 
            index = len(self._partial_revision_history_cache) - 1
2966
 
            if self._partial_revision_history_cache[index] != revision_id:
2967
 
                raise errors.NoSuchRevision(self, revision_id)
2968
 
        return self.revno() - index
2969
 
 
2970
 
 
2971
 
class BzrBranch7(BzrBranch8):
2972
 
    """A branch with support for a fallback repository."""
2973
 
 
2974
 
    def set_reference_info(self, file_id, tree_path, branch_location):
2975
 
        Branch.set_reference_info(self, file_id, tree_path, branch_location)
2976
 
 
2977
 
    def get_reference_info(self, file_id):
2978
 
        Branch.get_reference_info(self, file_id)
2979
 
 
2980
 
    def reference_parent(self, file_id, path, possible_transports=None):
2981
 
        return Branch.reference_parent(self, file_id, path,
2982
 
                                       possible_transports)
2983
 
 
2984
 
 
2985
 
class BzrBranch6(BzrBranch7):
2986
 
    """See BzrBranchFormat6 for the capabilities of this branch.
2987
 
 
2988
 
    This subclass of BzrBranch7 disables the new features BzrBranch7 added,
2989
 
    i.e. stacking.
 
1969
            revno = self.revision_id_to_revno(revision_id)
 
1970
        destination.set_last_revision_info(revno, revision_id)
 
1971
 
 
1972
    def _make_tags(self):
 
1973
        return BasicTags(self)
 
1974
 
 
1975
 
 
1976
class BranchTestProviderAdapter(object):
 
1977
    """A tool to generate a suite testing multiple branch formats at once.
 
1978
 
 
1979
    This is done by copying the test once for each transport and injecting
 
1980
    the transport_server, transport_readonly_server, and branch_format
 
1981
    classes into each copy. Each copy is also given a new id() to make it
 
1982
    easy to identify.
2990
1983
    """
2991
1984
 
2992
 
    def get_stacked_on_url(self):
2993
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
1985
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1986
        self._transport_server = transport_server
 
1987
        self._transport_readonly_server = transport_readonly_server
 
1988
        self._formats = formats
 
1989
    
 
1990
    def adapt(self, test):
 
1991
        result = TestSuite()
 
1992
        for branch_format, bzrdir_format in self._formats:
 
1993
            new_test = deepcopy(test)
 
1994
            new_test.transport_server = self._transport_server
 
1995
            new_test.transport_readonly_server = self._transport_readonly_server
 
1996
            new_test.bzrdir_format = bzrdir_format
 
1997
            new_test.branch_format = branch_format
 
1998
            def make_new_test_id():
 
1999
                # the format can be either a class or an instance
 
2000
                name = getattr(branch_format, '__name__',
 
2001
                        branch_format.__class__.__name__)
 
2002
                new_id = "%s(%s)" % (new_test.id(), name)
 
2003
                return lambda: new_id
 
2004
            new_test.id = make_new_test_id()
 
2005
            result.addTest(new_test)
 
2006
        return result
2994
2007
 
2995
2008
 
2996
2009
######################################################################
3014
2027
    :ivar new_revno: Revision number after pull.
3015
2028
    :ivar old_revid: Tip revision id before pull.
3016
2029
    :ivar new_revid: Tip revision id after pull.
3017
 
    :ivar source_branch: Source (local) branch object. (read locked)
3018
 
    :ivar master_branch: Master branch of the target, or the target if no
3019
 
        Master
3020
 
    :ivar local_branch: target branch if there is a Master, else None
3021
 
    :ivar target_branch: Target/destination branch object. (write locked)
3022
 
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
 
2030
    :ivar source_branch: Source (local) branch object.
 
2031
    :ivar master_branch: Master branch of the target, or None.
 
2032
    :ivar target_branch: Target/destination branch object.
3023
2033
    """
3024
2034
 
3025
2035
    def __int__(self):
3027
2037
        return self.new_revno - self.old_revno
3028
2038
 
3029
2039
    def report(self, to_file):
3030
 
        if not is_quiet():
3031
 
            if self.old_revid == self.new_revid:
3032
 
                to_file.write('No revisions to pull.\n')
3033
 
            else:
3034
 
                to_file.write('Now on revision %d.\n' % self.new_revno)
 
2040
        if self.old_revid == self.new_revid:
 
2041
            to_file.write('No revisions to pull.\n')
 
2042
        else:
 
2043
            to_file.write('Now on revision %d.\n' % self.new_revno)
3035
2044
        self._show_tag_conficts(to_file)
3036
2045
 
3037
2046
 
3038
 
class BranchPushResult(_Result):
 
2047
class PushResult(_Result):
3039
2048
    """Result of a Branch.push operation.
3040
2049
 
3041
 
    :ivar old_revno: Revision number (eg 10) of the target before push.
3042
 
    :ivar new_revno: Revision number (eg 12) of the target after push.
3043
 
    :ivar old_revid: Tip revision id (eg joe@foo.com-1234234-aoeua34) of target
3044
 
        before the push.
3045
 
    :ivar new_revid: Tip revision id (eg joe@foo.com-5676566-boa234a) of target
3046
 
        after the push.
3047
 
    :ivar source_branch: Source branch object that the push was from. This is
3048
 
        read locked, and generally is a local (and thus low latency) branch.
3049
 
    :ivar master_branch: If target is a bound branch, the master branch of
3050
 
        target, or target itself. Always write locked.
3051
 
    :ivar target_branch: The direct Branch where data is being sent (write
3052
 
        locked).
3053
 
    :ivar local_branch: If the target is a bound branch this will be the
3054
 
        target, otherwise it will be None.
 
2050
    :ivar old_revno: Revision number before push.
 
2051
    :ivar new_revno: Revision number after push.
 
2052
    :ivar old_revid: Tip revision id before push.
 
2053
    :ivar new_revid: Tip revision id after push.
 
2054
    :ivar source_branch: Source branch object.
 
2055
    :ivar master_branch: Master branch of the target, or None.
 
2056
    :ivar target_branch: Target/destination branch object.
3055
2057
    """
3056
2058
 
3057
2059
    def __int__(self):
3061
2063
    def report(self, to_file):
3062
2064
        """Write a human-readable description of the result."""
3063
2065
        if self.old_revid == self.new_revid:
3064
 
            note('No new revisions to push.')
 
2066
            to_file.write('No new revisions to push.\n')
3065
2067
        else:
3066
 
            note('Pushed up to revision %d.' % self.new_revno)
 
2068
            to_file.write('Pushed up to revision %d.\n' % self.new_revno)
3067
2069
        self._show_tag_conficts(to_file)
3068
2070
 
3069
2071
 
3075
2077
 
3076
2078
    def __init__(self, branch):
3077
2079
        self.branch = branch
3078
 
        self.errors = []
3079
2080
 
3080
2081
    def report_results(self, verbose):
3081
2082
        """Report the check results via trace.note.
3082
 
 
 
2083
        
3083
2084
        :param verbose: Requests more detailed display of what was checked,
3084
2085
            if any.
3085
2086
        """
3086
 
        note('checked branch %s format %s', self.branch.user_url,
3087
 
            self.branch._format)
3088
 
        for error in self.errors:
3089
 
            note('found error:%s', error)
 
2087
        note('checked branch %s format %s',
 
2088
             self.branch.base,
 
2089
             self.branch._format)
3090
2090
 
3091
2091
 
3092
2092
class Converter5to6(object):
3098
2098
        new_branch = format.open(branch.bzrdir, _found=True)
3099
2099
 
3100
2100
        # Copy source data into target
3101
 
        new_branch._write_last_revision_info(*branch.last_revision_info())
 
2101
        new_branch.set_last_revision_info(*branch.last_revision_info())
3102
2102
        new_branch.set_parent(branch.get_parent())
3103
2103
        new_branch.set_bound_location(branch.get_bound_location())
3104
2104
        new_branch.set_push_location(branch.get_push_location())
3107
2107
        new_branch.tags._set_tag_dict({})
3108
2108
 
3109
2109
        # Copying done; now update target format
3110
 
        new_branch._transport.put_bytes('format',
3111
 
            format.get_format_string(),
3112
 
            mode=new_branch.bzrdir._get_file_mode())
 
2110
        new_branch.control_files.put_utf8('format',
 
2111
            format.get_format_string())
3113
2112
 
3114
2113
        # Clean up old files
3115
 
        new_branch._transport.delete('revision-history')
 
2114
        new_branch.control_files._transport.delete('revision-history')
3116
2115
        try:
3117
2116
            branch.set_parent(None)
3118
 
        except errors.NoSuchFile:
 
2117
        except NoSuchFile:
3119
2118
            pass
3120
2119
        branch.set_bound_location(None)
3121
 
 
3122
 
 
3123
 
class Converter6to7(object):
3124
 
    """Perform an in-place upgrade of format 6 to format 7"""
3125
 
 
3126
 
    def convert(self, branch):
3127
 
        format = BzrBranchFormat7()
3128
 
        branch._set_config_location('stacked_on_location', '')
3129
 
        # update target format
3130
 
        branch._transport.put_bytes('format', format.get_format_string())
3131
 
 
3132
 
 
3133
 
class Converter7to8(object):
3134
 
    """Perform an in-place upgrade of format 6 to format 7"""
3135
 
 
3136
 
    def convert(self, branch):
3137
 
        format = BzrBranchFormat8()
3138
 
        branch._transport.put_bytes('references', '')
3139
 
        # update target format
3140
 
        branch._transport.put_bytes('format', format.get_format_string())
3141
 
 
3142
 
 
3143
 
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3144
 
    """Run ``callable(*args, **kwargs)``, write-locking target for the
3145
 
    duration.
3146
 
 
3147
 
    _run_with_write_locked_target will attempt to release the lock it acquires.
3148
 
 
3149
 
    If an exception is raised by callable, then that exception *will* be
3150
 
    propagated, even if the unlock attempt raises its own error.  Thus
3151
 
    _run_with_write_locked_target should be preferred to simply doing::
3152
 
 
3153
 
        target.lock_write()
3154
 
        try:
3155
 
            return callable(*args, **kwargs)
3156
 
        finally:
3157
 
            target.unlock()
3158
 
 
3159
 
    """
3160
 
    # This is very similar to bzrlib.decorators.needs_write_lock.  Perhaps they
3161
 
    # should share code?
3162
 
    target.lock_write()
3163
 
    try:
3164
 
        result = callable(*args, **kwargs)
3165
 
    except:
3166
 
        exc_info = sys.exc_info()
3167
 
        try:
3168
 
            target.unlock()
3169
 
        finally:
3170
 
            raise exc_info[0], exc_info[1], exc_info[2]
3171
 
    else:
3172
 
        target.unlock()
3173
 
        return result
3174
 
 
3175
 
 
3176
 
class InterBranch(InterObject):
3177
 
    """This class represents operations taking place between two branches.
3178
 
 
3179
 
    Its instances have methods like pull() and push() and contain
3180
 
    references to the source and target repositories these operations
3181
 
    can be carried out on.
3182
 
    """
3183
 
 
3184
 
    _optimisers = []
3185
 
    """The available optimised InterBranch types."""
3186
 
 
3187
 
    @staticmethod
3188
 
    def _get_branch_formats_to_test():
3189
 
        """Return a tuple with the Branch formats to use when testing."""
3190
 
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
3191
 
 
3192
 
    def pull(self, overwrite=False, stop_revision=None,
3193
 
             possible_transports=None, local=False):
3194
 
        """Mirror source into target branch.
3195
 
 
3196
 
        The target branch is considered to be 'local', having low latency.
3197
 
 
3198
 
        :returns: PullResult instance
3199
 
        """
3200
 
        raise NotImplementedError(self.pull)
3201
 
 
3202
 
    def update_revisions(self, stop_revision=None, overwrite=False,
3203
 
                         graph=None):
3204
 
        """Pull in new perfect-fit revisions.
3205
 
 
3206
 
        :param stop_revision: Updated until the given revision
3207
 
        :param overwrite: Always set the branch pointer, rather than checking
3208
 
            to see if it is a proper descendant.
3209
 
        :param graph: A Graph object that can be used to query history
3210
 
            information. This can be None.
3211
 
        :return: None
3212
 
        """
3213
 
        raise NotImplementedError(self.update_revisions)
3214
 
 
3215
 
    def push(self, overwrite=False, stop_revision=None,
3216
 
             _override_hook_source_branch=None):
3217
 
        """Mirror the source branch into the target branch.
3218
 
 
3219
 
        The source branch is considered to be 'local', having low latency.
3220
 
        """
3221
 
        raise NotImplementedError(self.push)
3222
 
 
3223
 
 
3224
 
class GenericInterBranch(InterBranch):
3225
 
    """InterBranch implementation that uses public Branch functions.
3226
 
    """
3227
 
 
3228
 
    @staticmethod
3229
 
    def _get_branch_formats_to_test():
3230
 
        return BranchFormat._default_format, BranchFormat._default_format
3231
 
 
3232
 
    def update_revisions(self, stop_revision=None, overwrite=False,
3233
 
        graph=None):
3234
 
        """See InterBranch.update_revisions()."""
3235
 
        self.source.lock_read()
3236
 
        try:
3237
 
            other_revno, other_last_revision = self.source.last_revision_info()
3238
 
            stop_revno = None # unknown
3239
 
            if stop_revision is None:
3240
 
                stop_revision = other_last_revision
3241
 
                if _mod_revision.is_null(stop_revision):
3242
 
                    # if there are no commits, we're done.
3243
 
                    return
3244
 
                stop_revno = other_revno
3245
 
 
3246
 
            # what's the current last revision, before we fetch [and change it
3247
 
            # possibly]
3248
 
            last_rev = _mod_revision.ensure_null(self.target.last_revision())
3249
 
            # we fetch here so that we don't process data twice in the common
3250
 
            # case of having something to pull, and so that the check for
3251
 
            # already merged can operate on the just fetched graph, which will
3252
 
            # be cached in memory.
3253
 
            self.target.fetch(self.source, stop_revision)
3254
 
            # Check to see if one is an ancestor of the other
3255
 
            if not overwrite:
3256
 
                if graph is None:
3257
 
                    graph = self.target.repository.get_graph()
3258
 
                if self.target._check_if_descendant_or_diverged(
3259
 
                        stop_revision, last_rev, graph, self.source):
3260
 
                    # stop_revision is a descendant of last_rev, but we aren't
3261
 
                    # overwriting, so we're done.
3262
 
                    return
3263
 
            if stop_revno is None:
3264
 
                if graph is None:
3265
 
                    graph = self.target.repository.get_graph()
3266
 
                this_revno, this_last_revision = \
3267
 
                        self.target.last_revision_info()
3268
 
                stop_revno = graph.find_distance_to_null(stop_revision,
3269
 
                                [(other_last_revision, other_revno),
3270
 
                                 (this_last_revision, this_revno)])
3271
 
            self.target.set_last_revision_info(stop_revno, stop_revision)
3272
 
        finally:
3273
 
            self.source.unlock()
3274
 
 
3275
 
    def pull(self, overwrite=False, stop_revision=None,
3276
 
             possible_transports=None, _hook_master=None, run_hooks=True,
3277
 
             _override_hook_target=None, local=False):
3278
 
        """See Branch.pull.
3279
 
 
3280
 
        :param _hook_master: Private parameter - set the branch to
3281
 
            be supplied as the master to pull hooks.
3282
 
        :param run_hooks: Private parameter - if false, this branch
3283
 
            is being called because it's the master of the primary branch,
3284
 
            so it should not run its hooks.
3285
 
        :param _override_hook_target: Private parameter - set the branch to be
3286
 
            supplied as the target_branch to pull hooks.
3287
 
        :param local: Only update the local branch, and not the bound branch.
3288
 
        """
3289
 
        # This type of branch can't be bound.
3290
 
        if local:
3291
 
            raise errors.LocalRequiresBoundBranch()
3292
 
        result = PullResult()
3293
 
        result.source_branch = self.source
3294
 
        if _override_hook_target is None:
3295
 
            result.target_branch = self.target
3296
 
        else:
3297
 
            result.target_branch = _override_hook_target
3298
 
        self.source.lock_read()
3299
 
        try:
3300
 
            # We assume that during 'pull' the target repository is closer than
3301
 
            # the source one.
3302
 
            self.source.update_references(self.target)
3303
 
            graph = self.target.repository.get_graph(self.source.repository)
3304
 
            # TODO: Branch formats should have a flag that indicates 
3305
 
            # that revno's are expensive, and pull() should honor that flag.
3306
 
            # -- JRV20090506
3307
 
            result.old_revno, result.old_revid = \
3308
 
                self.target.last_revision_info()
3309
 
            self.target.update_revisions(self.source, stop_revision,
3310
 
                overwrite=overwrite, graph=graph)
3311
 
            # TODO: The old revid should be specified when merging tags, 
3312
 
            # so a tags implementation that versions tags can only 
3313
 
            # pull in the most recent changes. -- JRV20090506
3314
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3315
 
                overwrite)
3316
 
            result.new_revno, result.new_revid = self.target.last_revision_info()
3317
 
            if _hook_master:
3318
 
                result.master_branch = _hook_master
3319
 
                result.local_branch = result.target_branch
3320
 
            else:
3321
 
                result.master_branch = result.target_branch
3322
 
                result.local_branch = None
3323
 
            if run_hooks:
3324
 
                for hook in Branch.hooks['post_pull']:
3325
 
                    hook(result)
3326
 
        finally:
3327
 
            self.source.unlock()
3328
 
        return result
3329
 
 
3330
 
    def push(self, overwrite=False, stop_revision=None,
3331
 
             _override_hook_source_branch=None):
3332
 
        """See InterBranch.push.
3333
 
 
3334
 
        This is the basic concrete implementation of push()
3335
 
 
3336
 
        :param _override_hook_source_branch: If specified, run
3337
 
        the hooks passing this Branch as the source, rather than self.
3338
 
        This is for use of RemoteBranch, where push is delegated to the
3339
 
        underlying vfs-based Branch.
3340
 
        """
3341
 
        # TODO: Public option to disable running hooks - should be trivial but
3342
 
        # needs tests.
3343
 
        self.source.lock_read()
3344
 
        try:
3345
 
            return _run_with_write_locked_target(
3346
 
                self.target, self._push_with_bound_branches, overwrite,
3347
 
                stop_revision,
3348
 
                _override_hook_source_branch=_override_hook_source_branch)
3349
 
        finally:
3350
 
            self.source.unlock()
3351
 
 
3352
 
    def _push_with_bound_branches(self, overwrite, stop_revision,
3353
 
            _override_hook_source_branch=None):
3354
 
        """Push from source into target, and into target's master if any.
3355
 
        """
3356
 
        def _run_hooks():
3357
 
            if _override_hook_source_branch:
3358
 
                result.source_branch = _override_hook_source_branch
3359
 
            for hook in Branch.hooks['post_push']:
3360
 
                hook(result)
3361
 
 
3362
 
        bound_location = self.target.get_bound_location()
3363
 
        if bound_location and self.target.base != bound_location:
3364
 
            # there is a master branch.
3365
 
            #
3366
 
            # XXX: Why the second check?  Is it even supported for a branch to
3367
 
            # be bound to itself? -- mbp 20070507
3368
 
            master_branch = self.target.get_master_branch()
3369
 
            master_branch.lock_write()
3370
 
            try:
3371
 
                # push into the master from the source branch.
3372
 
                self.source._basic_push(master_branch, overwrite, stop_revision)
3373
 
                # and push into the target branch from the source. Note that we
3374
 
                # push from the source branch again, because its considered the
3375
 
                # highest bandwidth repository.
3376
 
                result = self.source._basic_push(self.target, overwrite,
3377
 
                    stop_revision)
3378
 
                result.master_branch = master_branch
3379
 
                result.local_branch = self.target
3380
 
                _run_hooks()
3381
 
                return result
3382
 
            finally:
3383
 
                master_branch.unlock()
3384
 
        else:
3385
 
            # no master branch
3386
 
            result = self.source._basic_push(self.target, overwrite,
3387
 
                stop_revision)
3388
 
            # TODO: Why set master_branch and local_branch if there's no
3389
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
3390
 
            # 20070504
3391
 
            result.master_branch = self.target
3392
 
            result.local_branch = None
3393
 
            _run_hooks()
3394
 
            return result
3395
 
 
3396
 
    @classmethod
3397
 
    def is_compatible(self, source, target):
3398
 
        # GenericBranch uses the public API, so always compatible
3399
 
        return True
3400
 
 
3401
 
 
3402
 
class InterToBranch5(GenericInterBranch):
3403
 
 
3404
 
    @staticmethod
3405
 
    def _get_branch_formats_to_test():
3406
 
        return BranchFormat._default_format, BzrBranchFormat5()
3407
 
 
3408
 
    def pull(self, overwrite=False, stop_revision=None,
3409
 
             possible_transports=None, run_hooks=True,
3410
 
             _override_hook_target=None, local=False):
3411
 
        """Pull from source into self, updating my master if any.
3412
 
 
3413
 
        :param run_hooks: Private parameter - if false, this branch
3414
 
            is being called because it's the master of the primary branch,
3415
 
            so it should not run its hooks.
3416
 
        """
3417
 
        bound_location = self.target.get_bound_location()
3418
 
        if local and not bound_location:
3419
 
            raise errors.LocalRequiresBoundBranch()
3420
 
        master_branch = None
3421
 
        if not local and bound_location and self.source.user_url != bound_location:
3422
 
            # not pulling from master, so we need to update master.
3423
 
            master_branch = self.target.get_master_branch(possible_transports)
3424
 
            master_branch.lock_write()
3425
 
        try:
3426
 
            if master_branch:
3427
 
                # pull from source into master.
3428
 
                master_branch.pull(self.source, overwrite, stop_revision,
3429
 
                    run_hooks=False)
3430
 
            return super(InterToBranch5, self).pull(overwrite,
3431
 
                stop_revision, _hook_master=master_branch,
3432
 
                run_hooks=run_hooks,
3433
 
                _override_hook_target=_override_hook_target)
3434
 
        finally:
3435
 
            if master_branch:
3436
 
                master_branch.unlock()
3437
 
 
3438
 
 
3439
 
InterBranch.register_optimiser(GenericInterBranch)
3440
 
InterBranch.register_optimiser(InterToBranch5)