~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

Added support for branch nicks

Show diffs side-by-side

added added

removed removed

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