~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

Don't encode unicode messages to UTF-8 in mutter() (the stream writer does it).

Use a codec wrapped log file in tests to match the real environment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
 
18
import shutil
 
19
import sys
 
20
import os
 
21
import errno
 
22
from warnings import warn
18
23
from cStringIO import StringIO
19
24
 
20
 
from bzrlib.lazy_import import lazy_import
21
 
lazy_import(globals(), """
22
 
from copy import deepcopy
23
 
from unittest import TestSuite
24
 
from warnings import warn
25
25
 
26
26
import bzrlib
27
 
from bzrlib import (
28
 
        bzrdir,
29
 
        cache_utf8,
30
 
        config as _mod_config,
31
 
        errors,
32
 
        lockdir,
33
 
        lockable_files,
34
 
        osutils,
35
 
        revision as _mod_revision,
36
 
        transport,
37
 
        tree,
38
 
        tsort,
39
 
        ui,
40
 
        urlutils,
41
 
        )
42
 
from bzrlib.config import BranchConfig, TreeConfig
43
 
from bzrlib.lockable_files import LockableFiles, TransportLock
44
 
from bzrlib.tag import (
45
 
    BasicTags,
46
 
    DisabledTags,
47
 
    )
48
 
""")
49
 
 
50
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
51
 
from bzrlib.errors import (BzrError, BzrCheckError, DivergedBranches,
52
 
                           HistoryMissing, InvalidRevisionId,
53
 
                           InvalidRevisionNumber, LockError, NoSuchFile,
54
 
                           NoSuchRevision, NoWorkingTree, NotVersionedError,
55
 
                           NotBranchError, UninitializableFormat,
56
 
                           UnlistableStore, UnlistableBranch,
57
 
                           )
58
 
from bzrlib.hooks import Hooks
59
 
from bzrlib.symbol_versioning import (deprecated_function,
60
 
                                      deprecated_method,
61
 
                                      DEPRECATED_PARAMETER,
62
 
                                      deprecated_passed,
63
 
                                      zero_eight, zero_nine, zero_sixteen,
64
 
                                      )
 
27
import bzrlib.inventory as inventory
65
28
from bzrlib.trace import mutter, note
 
29
from bzrlib.osutils import (isdir, quotefn,
 
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
                           NoWorkingTree)
 
38
from bzrlib.textui import show_status
 
39
from bzrlib.revision import (Revision, is_ancestor, get_intervening_revisions,
 
40
                             NULL_REVISION)
 
41
 
 
42
from bzrlib.delta import compare_trees
 
43
from bzrlib.tree import EmptyTree, RevisionTree
 
44
from bzrlib.inventory import Inventory
 
45
from bzrlib.store import copy_all
 
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
66
54
 
67
55
 
68
56
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
69
57
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
70
 
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
71
 
 
72
 
 
73
 
# 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
 
74
61
 
75
62
# TODO: Some operations like log might retrieve the same revisions
76
63
# repeatedly to calculate deltas.  We could perhaps have a weakref
77
64
# cache in memory to make this faster.  In general anything can be
78
 
# cached in memory between lock and unlock operations. .. nb thats
79
 
# what the transaction identity map provides
80
 
 
 
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
81
93
 
82
94
######################################################################
83
95
# branch objects
87
99
 
88
100
    base
89
101
        Base directory/url of the branch.
90
 
 
91
 
    hooks: An instance of BranchHooks.
92
102
    """
93
 
    # this is really an instance variable - FIXME move it there
94
 
    # - RBC 20060112
95
103
    base = None
96
104
 
97
 
    # override this to set the strategy for storing tags
98
 
    def _make_tags(self):
99
 
        return DisabledTags(self)
100
 
 
101
105
    def __init__(self, *ignored, **ignored_too):
102
 
        self.tags = self._make_tags()
103
 
        self._revision_history_cache = None
104
 
        self._revision_id_to_revno_cache = None
105
 
 
106
 
    def break_lock(self):
107
 
        """Break a lock if one is present from another instance.
108
 
 
109
 
        Uses the ui factory to ask for confirmation if the lock may be from
110
 
        an active process.
111
 
 
112
 
        This will probe the repository for its lock as well.
113
 
        """
114
 
        self.control_files.break_lock()
115
 
        self.repository.break_lock()
116
 
        master = self.get_master_branch()
117
 
        if master is not None:
118
 
            master.break_lock()
 
106
        raise NotImplementedError('The Branch class is abstract')
119
107
 
120
108
    @staticmethod
121
 
    @deprecated_method(zero_eight)
122
109
    def open_downlevel(base):
123
 
        """Open a branch which may be of an old format."""
124
 
        return Branch.open(base, _unsupported=True)
 
110
        """Open a branch which may be of an old format.
 
111
        
 
112
        Only local branches are supported."""
 
113
        return BzrBranch(get_transport(base), relax_version_check=True)
125
114
        
126
115
    @staticmethod
127
 
    def open(base, _unsupported=False):
128
 
        """Open the branch rooted at base.
129
 
 
130
 
        For instance, if the branch is at URL/.bzr/branch,
131
 
        Branch.open(URL) -> a Branch instance.
132
 
        """
133
 
        control = bzrdir.BzrDir.open(base, _unsupported)
134
 
        return control.open_branch(_unsupported)
 
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 BzrBranch(t)
135
121
 
136
122
    @staticmethod
137
123
    def open_containing(url):
141
127
 
142
128
        Basically we keep looking up until we find the control directory or
143
129
        run into the root.  If there isn't one, raises NotBranchError.
144
 
        If there is one and it is either an unrecognised format or an unsupported 
145
 
        format, UnknownFormatError or UnsupportedFormatError are raised.
146
130
        If there is one, it is returned, along with the unused portion of url.
147
131
        """
148
 
        control, relpath = bzrdir.BzrDir.open_containing(url)
149
 
        return control.open_branch(), relpath
 
132
        t = get_transport(url)
 
133
        while True:
 
134
            try:
 
135
                return BzrBranch(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
150
143
 
151
144
    @staticmethod
152
 
    @deprecated_function(zero_eight)
153
145
    def initialize(base):
154
 
        """Create a new working tree and branch, rooted at 'base' (url)
155
 
 
156
 
        NOTE: This will soon be deprecated in favour of creation
157
 
        through a BzrDir.
158
 
        """
159
 
        return bzrdir.BzrDir.create_standalone_workingtree(base).branch
160
 
 
161
 
    @deprecated_function(zero_eight)
 
146
        """Create a new branch, rooted at 'base' (url)"""
 
147
        t = get_transport(base)
 
148
        return BzrBranch(t, init=True)
 
149
 
162
150
    def setup_caching(self, cache_root):
163
151
        """Subclasses that care about caching should override this, and set
164
152
        up cached stores located under cache_root.
165
 
        
166
 
        NOTE: This is unused.
167
153
        """
168
 
        pass
169
 
 
170
 
    def get_config(self):
171
 
        return BranchConfig(self)
 
154
        self.cache_root = cache_root
172
155
 
173
156
    def _get_nick(self):
174
 
        return self.get_config().get_nickname()
 
157
        cfg = self.tree_config()
 
158
        return cfg.get_option(u"nickname", default=self.base.split('/')[-1])
175
159
 
176
160
    def _set_nick(self, nick):
177
 
        self.get_config().set_user_option('nickname', nick)
 
161
        cfg = self.tree_config()
 
162
        cfg.set_option(nick, "nickname")
 
163
        assert cfg.get_option("nickname") == nick
178
164
 
179
165
    nick = property(_get_nick, _set_nick)
180
 
 
181
 
    def is_locked(self):
182
 
        raise NotImplementedError(self.is_locked)
 
166
        
 
167
    def push_stores(self, branch_to):
 
168
        """Copy the content of this branches store to branch_to."""
 
169
        raise NotImplementedError('push_stores is abstract')
 
170
 
 
171
    def get_transaction(self):
 
172
        """Return the current active transaction.
 
173
 
 
174
        If no transaction is active, this returns a passthrough object
 
175
        for which all data is immediately flushed and no caching happens.
 
176
        """
 
177
        raise NotImplementedError('get_transaction is abstract')
183
178
 
184
179
    def lock_write(self):
185
 
        raise NotImplementedError(self.lock_write)
186
 
 
 
180
        raise NotImplementedError('lock_write is abstract')
 
181
        
187
182
    def lock_read(self):
188
 
        raise NotImplementedError(self.lock_read)
 
183
        raise NotImplementedError('lock_read is abstract')
189
184
 
190
185
    def unlock(self):
191
 
        raise NotImplementedError(self.unlock)
192
 
 
193
 
    def peek_lock_mode(self):
194
 
        """Return lock mode for the Branch: 'r', 'w' or None"""
195
 
        raise NotImplementedError(self.peek_lock_mode)
196
 
 
197
 
    def get_physical_lock_status(self):
198
 
        raise NotImplementedError(self.get_physical_lock_status)
199
 
 
200
 
    @needs_read_lock
201
 
    def get_revision_id_to_revno_map(self):
202
 
        """Return the revision_id => dotted revno map.
203
 
 
204
 
        This will be regenerated on demand, but will be cached.
205
 
 
206
 
        :return: A dictionary mapping revision_id => dotted revno.
207
 
            This dictionary should not be modified by the caller.
208
 
        """
209
 
        if self._revision_id_to_revno_cache is not None:
210
 
            mapping = self._revision_id_to_revno_cache
211
 
        else:
212
 
            mapping = self._gen_revno_map()
213
 
            self._cache_revision_id_to_revno(mapping)
214
 
        # TODO: jam 20070417 Since this is being cached, should we be returning
215
 
        #       a copy?
216
 
        # I would rather not, and instead just declare that users should not
217
 
        # modify the return value.
218
 
        return mapping
219
 
 
220
 
    def _gen_revno_map(self):
221
 
        """Create a new mapping from revision ids to dotted revnos.
222
 
 
223
 
        Dotted revnos are generated based on the current tip in the revision
224
 
        history.
225
 
        This is the worker function for get_revision_id_to_revno_map, which
226
 
        just caches the return value.
227
 
 
228
 
        :return: A dictionary mapping revision_id => dotted revno.
229
 
        """
230
 
        last_revision = self.last_revision()
231
 
        revision_graph = self.repository.get_revision_graph(last_revision)
232
 
        merge_sorted_revisions = tsort.merge_sort(
233
 
            revision_graph,
234
 
            last_revision,
235
 
            None,
236
 
            generate_revno=True)
237
 
        revision_id_to_revno = dict((rev_id, revno)
238
 
                                    for seq_num, rev_id, depth, revno, end_of_merge
239
 
                                     in merge_sorted_revisions)
240
 
        return revision_id_to_revno
241
 
 
242
 
    def leave_lock_in_place(self):
243
 
        """Tell this branch object not to release the physical lock when this
244
 
        object is unlocked.
245
 
        
246
 
        If lock_write doesn't return a token, then this method is not supported.
247
 
        """
248
 
        self.control_files.leave_in_place()
249
 
 
250
 
    def dont_leave_lock_in_place(self):
251
 
        """Tell this branch object to release the physical lock when this
252
 
        object is unlocked, even if it didn't originally acquire it.
253
 
 
254
 
        If lock_write doesn't return a token, then this method is not supported.
255
 
        """
256
 
        self.control_files.dont_leave_in_place()
 
186
        raise NotImplementedError('unlock is abstract')
257
187
 
258
188
    def abspath(self, name):
259
189
        """Return absolute filename for something in the branch
261
191
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
262
192
        method and not a tree method.
263
193
        """
264
 
        raise NotImplementedError(self.abspath)
265
 
 
266
 
    def bind(self, other):
267
 
        """Bind the local branch the other branch.
268
 
 
269
 
        :param other: The branch to bind to
270
 
        :type other: Branch
271
 
        """
272
 
        raise errors.UpgradeRequired(self.base)
273
 
 
274
 
    @needs_write_lock
275
 
    def fetch(self, from_branch, last_revision=None, pb=None):
276
 
        """Copy revisions from from_branch into this branch.
277
 
 
278
 
        :param from_branch: Where to copy from.
279
 
        :param last_revision: What revision to stop at (None for at the end
280
 
                              of the branch.
281
 
        :param pb: An optional progress bar to use.
282
 
 
283
 
        Returns the copied revision count and the failed revisions in a tuple:
284
 
        (copied, failures).
285
 
        """
286
 
        if self.base == from_branch.base:
287
 
            return (0, [])
288
 
        if pb is None:
289
 
            nested_pb = ui.ui_factory.nested_progress_bar()
290
 
            pb = nested_pb
291
 
        else:
292
 
            nested_pb = None
293
 
 
294
 
        from_branch.lock_read()
295
 
        try:
296
 
            if last_revision is None:
297
 
                pb.update('get source history')
298
 
                last_revision = from_branch.last_revision()
299
 
                if last_revision is None:
300
 
                    last_revision = _mod_revision.NULL_REVISION
301
 
            return self.repository.fetch(from_branch.repository,
302
 
                                         revision_id=last_revision,
303
 
                                         pb=nested_pb)
304
 
        finally:
305
 
            if nested_pb is not None:
306
 
                nested_pb.finished()
307
 
            from_branch.unlock()
308
 
 
309
 
    def get_bound_location(self):
310
 
        """Return the URL of the branch we are bound to.
311
 
 
312
 
        Older format branches cannot bind, please be sure to use a metadir
313
 
        branch.
314
 
        """
315
 
        return None
316
 
    
317
 
    def get_old_bound_location(self):
318
 
        """Return the URL of the branch we used to be bound to
319
 
        """
320
 
        raise errors.UpgradeRequired(self.base)
321
 
 
322
 
    def get_commit_builder(self, parents, config=None, timestamp=None, 
323
 
                           timezone=None, committer=None, revprops=None, 
324
 
                           revision_id=None):
325
 
        """Obtain a CommitBuilder for this branch.
326
 
        
327
 
        :param parents: Revision ids of the parents of the new revision.
328
 
        :param config: Optional configuration to use.
329
 
        :param timestamp: Optional timestamp recorded for commit.
330
 
        :param timezone: Optional timezone for timestamp.
331
 
        :param committer: Optional committer to set for commit.
332
 
        :param revprops: Optional dictionary of revision properties.
333
 
        :param revision_id: Optional revision id.
334
 
        """
335
 
 
336
 
        if config is None:
337
 
            config = self.get_config()
338
 
        
339
 
        return self.repository.get_commit_builder(self, parents, config,
340
 
            timestamp, timezone, committer, revprops, revision_id)
341
 
 
342
 
    def get_master_branch(self):
343
 
        """Return the branch we are bound to.
344
 
        
345
 
        :return: Either a Branch, or None
346
 
        """
347
 
        return None
 
194
        raise NotImplementedError('abspath is abstract')
 
195
 
 
196
    def controlfilename(self, file_or_path):
 
197
        """Return location relative to branch."""
 
198
        raise NotImplementedError('controlfilename is abstract')
 
199
 
 
200
    def controlfile(self, file_or_path, mode='r'):
 
201
        """Open a control file for this branch.
 
202
 
 
203
        There are two classes of file in the control directory: text
 
204
        and binary.  binary files are untranslated byte streams.  Text
 
205
        control files are stored with Unix newlines and in UTF-8, even
 
206
        if the platform or locale defaults are different.
 
207
 
 
208
        Controlfiles should almost never be opened in write mode but
 
209
        rather should be atomically copied and replaced using atomicfile.
 
210
        """
 
211
        raise NotImplementedError('controlfile is abstract')
 
212
 
 
213
    def put_controlfile(self, path, f, encode=True):
 
214
        """Write an entry as a controlfile.
 
215
 
 
216
        :param path: The path to put the file, relative to the .bzr control
 
217
                     directory
 
218
        :param f: A file-like or string object whose contents should be copied.
 
219
        :param encode:  If true, encode the contents as utf-8
 
220
        """
 
221
        raise NotImplementedError('put_controlfile is abstract')
 
222
 
 
223
    def put_controlfiles(self, files, encode=True):
 
224
        """Write several entries as controlfiles.
 
225
 
 
226
        :param files: A list of [(path, file)] pairs, where the path is the directory
 
227
                      underneath the bzr control directory
 
228
        :param encode:  If true, encode the contents as utf-8
 
229
        """
 
230
        raise NotImplementedError('put_controlfiles is abstract')
 
231
 
 
232
    def get_root_id(self):
 
233
        """Return the id of this branches root"""
 
234
        raise NotImplementedError('get_root_id is abstract')
 
235
 
 
236
    def set_root_id(self, file_id):
 
237
        raise NotImplementedError('set_root_id is abstract')
 
238
 
 
239
    def print_file(self, file, revno):
 
240
        """Print `file` to stdout."""
 
241
        raise NotImplementedError('print_file is abstract')
 
242
 
 
243
    def append_revision(self, *revision_ids):
 
244
        raise NotImplementedError('append_revision is abstract')
 
245
 
 
246
    def set_revision_history(self, rev_history):
 
247
        raise NotImplementedError('set_revision_history is abstract')
 
248
 
 
249
    def has_revision(self, revision_id):
 
250
        """True if this branch has a copy of the revision.
 
251
 
 
252
        This does not necessarily imply the revision is merge
 
253
        or on the mainline."""
 
254
        raise NotImplementedError('has_revision is abstract')
 
255
 
 
256
    def get_revision_xml(self, revision_id):
 
257
        raise NotImplementedError('get_revision_xml is abstract')
 
258
 
 
259
    def get_revision(self, revision_id):
 
260
        """Return the Revision object for a named revision"""
 
261
        raise NotImplementedError('get_revision is abstract')
348
262
 
349
263
    def get_revision_delta(self, revno):
350
264
        """Return the delta for one revision.
356
270
        rh = self.revision_history()
357
271
        if not (1 <= revno <= len(rh)):
358
272
            raise InvalidRevisionNumber(revno)
359
 
        return self.repository.get_revision_delta(rh[revno-1])
360
 
 
361
 
    @deprecated_method(zero_sixteen)
362
 
    def get_root_id(self):
363
 
        """Return the id of this branches root
364
 
 
365
 
        Deprecated: branches don't have root ids-- trees do.
366
 
        Use basis_tree().get_root_id() instead.
367
 
        """
368
 
        raise NotImplementedError(self.get_root_id)
369
 
 
370
 
    def print_file(self, file, revision_id):
371
 
        """Print `file` to stdout."""
372
 
        raise NotImplementedError(self.print_file)
373
 
 
374
 
    def append_revision(self, *revision_ids):
375
 
        raise NotImplementedError(self.append_revision)
376
 
 
377
 
    def set_revision_history(self, rev_history):
378
 
        raise NotImplementedError(self.set_revision_history)
379
 
 
380
 
    def _cache_revision_history(self, rev_history):
381
 
        """Set the cached revision history to rev_history.
382
 
 
383
 
        The revision_history method will use this cache to avoid regenerating
384
 
        the revision history.
385
 
 
386
 
        This API is semi-public; it only for use by subclasses, all other code
387
 
        should consider it to be private.
388
 
        """
389
 
        self._revision_history_cache = rev_history
390
 
 
391
 
    def _cache_revision_id_to_revno(self, revision_id_to_revno):
392
 
        """Set the cached revision_id => revno map to revision_id_to_revno.
393
 
 
394
 
        This API is semi-public; it only for use by subclasses, all other code
395
 
        should consider it to be private.
396
 
        """
397
 
        self._revision_id_to_revno_cache = revision_id_to_revno
398
 
 
399
 
    def _clear_cached_state(self):
400
 
        """Clear any cached data on this branch, e.g. cached revision history.
401
 
 
402
 
        This means the next call to revision_history will need to call
403
 
        _gen_revision_history.
404
 
 
405
 
        This API is semi-public; it only for use by subclasses, all other code
406
 
        should consider it to be private.
407
 
        """
408
 
        self._revision_history_cache = None
409
 
        self._revision_id_to_revno_cache = None
410
 
 
411
 
    def _gen_revision_history(self):
412
 
        """Return sequence of revision hashes on to this branch.
413
 
        
414
 
        Unlike revision_history, this method always regenerates or rereads the
415
 
        revision history, i.e. it does not cache the result, so repeated calls
416
 
        may be expensive.
417
 
 
418
 
        Concrete subclasses should override this instead of revision_history so
419
 
        that subclasses do not need to deal with caching logic.
420
 
        
421
 
        This API is semi-public; it only for use by subclasses, all other code
422
 
        should consider it to be private.
423
 
        """
424
 
        raise NotImplementedError(self._gen_revision_history)
425
 
 
426
 
    @needs_read_lock
 
273
 
 
274
        # revno is 1-based; list is 0-based
 
275
 
 
276
        new_tree = self.revision_tree(rh[revno-1])
 
277
        if revno == 1:
 
278
            old_tree = EmptyTree()
 
279
        else:
 
280
            old_tree = self.revision_tree(rh[revno-2])
 
281
 
 
282
        return compare_trees(old_tree, new_tree)
 
283
 
 
284
    def get_revision_sha1(self, revision_id):
 
285
        """Hash the stored value of a revision, and return it."""
 
286
        raise NotImplementedError('get_revision_sha1 is abstract')
 
287
 
 
288
    def get_ancestry(self, revision_id):
 
289
        """Return a list of revision-ids integrated by a revision.
 
290
        
 
291
        This currently returns a list, but the ordering is not guaranteed:
 
292
        treat it as a set.
 
293
        """
 
294
        raise NotImplementedError('get_ancestry is abstract')
 
295
 
 
296
    def get_inventory(self, revision_id):
 
297
        """Get Inventory object by hash."""
 
298
        raise NotImplementedError('get_inventory is abstract')
 
299
 
 
300
    def get_inventory_xml(self, revision_id):
 
301
        """Get inventory XML as a file object."""
 
302
        raise NotImplementedError('get_inventory_xml is abstract')
 
303
 
 
304
    def get_inventory_sha1(self, revision_id):
 
305
        """Return the sha1 hash of the inventory entry."""
 
306
        raise NotImplementedError('get_inventory_sha1 is abstract')
 
307
 
 
308
    def get_revision_inventory(self, revision_id):
 
309
        """Return inventory of a past revision."""
 
310
        raise NotImplementedError('get_revision_inventory is abstract')
 
311
 
427
312
    def revision_history(self):
428
 
        """Return sequence of revision hashes on to this branch.
429
 
        
430
 
        This method will cache the revision history for as long as it is safe to
431
 
        do so.
432
 
        """
433
 
        if self._revision_history_cache is not None:
434
 
            history = self._revision_history_cache
435
 
        else:
436
 
            history = self._gen_revision_history()
437
 
            self._cache_revision_history(history)
438
 
        return list(history)
 
313
        """Return sequence of revision hashes on to this branch."""
 
314
        raise NotImplementedError('revision_history is abstract')
439
315
 
440
316
    def revno(self):
441
317
        """Return current revision number for this branch.
445
321
        """
446
322
        return len(self.revision_history())
447
323
 
448
 
    def unbind(self):
449
 
        """Older format branches cannot bind or unbind."""
450
 
        raise errors.UpgradeRequired(self.base)
451
 
 
452
 
    def set_append_revisions_only(self, enabled):
453
 
        """Older format branches are never restricted to append-only"""
454
 
        raise errors.UpgradeRequired(self.base)
455
 
 
456
324
    def last_revision(self):
457
 
        """Return last revision id, or None"""
 
325
        """Return last patch hash, or None if no history."""
458
326
        ph = self.revision_history()
459
327
        if ph:
460
328
            return ph[-1]
461
329
        else:
462
330
            return None
463
331
 
464
 
    def last_revision_info(self):
465
 
        """Return information about the last revision.
466
 
 
467
 
        :return: A tuple (revno, last_revision_id).
468
 
        """
469
 
        rh = self.revision_history()
470
 
        revno = len(rh)
471
 
        if revno:
472
 
            return (revno, rh[-1])
473
 
        else:
474
 
            return (0, _mod_revision.NULL_REVISION)
475
 
 
476
 
    def missing_revisions(self, other, stop_revision=None):
 
332
    def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
477
333
        """Return a list of new revisions that would perfectly fit.
478
334
        
479
335
        If self and other have not diverged, return a list of the revisions
480
336
        present in other, but missing from self.
 
337
 
 
338
        >>> from bzrlib.commit import commit
 
339
        >>> bzrlib.trace.silent = True
 
340
        >>> br1 = ScratchBranch()
 
341
        >>> br2 = ScratchBranch()
 
342
        >>> br1.missing_revisions(br2)
 
343
        []
 
344
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
 
345
        >>> br1.missing_revisions(br2)
 
346
        [u'REVISION-ID-1']
 
347
        >>> br2.missing_revisions(br1)
 
348
        []
 
349
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
 
350
        >>> br1.missing_revisions(br2)
 
351
        []
 
352
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
 
353
        >>> br1.missing_revisions(br2)
 
354
        [u'REVISION-ID-2A']
 
355
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
 
356
        >>> br1.missing_revisions(br2)
 
357
        Traceback (most recent call last):
 
358
        DivergedBranches: These branches have diverged.
481
359
        """
482
360
        self_history = self.revision_history()
483
361
        self_len = len(self_history)
493
371
        else:
494
372
            assert isinstance(stop_revision, int)
495
373
            if stop_revision > other_len:
496
 
                raise errors.NoSuchRevision(self, stop_revision)
 
374
                raise bzrlib.errors.NoSuchRevision(self, stop_revision)
497
375
        return other_history[self_len:stop_revision]
498
 
 
 
376
    
499
377
    def update_revisions(self, other, stop_revision=None):
500
 
        """Pull in new perfect-fit revisions.
501
 
 
502
 
        :param other: Another Branch to pull from
503
 
        :param stop_revision: Updated until the given revision
504
 
        :return: None
505
 
        """
506
 
        raise NotImplementedError(self.update_revisions)
507
 
 
 
378
        """Pull in new perfect-fit revisions."""
 
379
        raise NotImplementedError('update_revisions is abstract')
 
380
 
 
381
    def pullable_revisions(self, other, stop_revision):
 
382
        raise NotImplementedError('pullable_revisions is abstract')
 
383
        
508
384
    def revision_id_to_revno(self, revision_id):
509
385
        """Given a revision id, return its revno"""
510
386
        if revision_id is None:
511
387
            return 0
512
 
        revision_id = osutils.safe_revision_id(revision_id)
513
388
        history = self.revision_history()
514
389
        try:
515
390
            return history.index(revision_id) + 1
516
391
        except ValueError:
517
 
            raise errors.NoSuchRevision(self, revision_id)
 
392
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
518
393
 
519
394
    def get_rev_id(self, revno, history=None):
520
395
        """Find the revision id of the specified revno."""
522
397
            return None
523
398
        if history is None:
524
399
            history = self.revision_history()
525
 
        if revno <= 0 or revno > len(history):
526
 
            raise errors.NoSuchRevision(self, revno)
 
400
        elif revno <= 0 or revno > len(history):
 
401
            raise bzrlib.errors.NoSuchRevision(self, revno)
527
402
        return history[revno - 1]
528
403
 
529
 
    def pull(self, source, overwrite=False, stop_revision=None):
530
 
        """Mirror source into this branch.
531
 
 
532
 
        This branch is considered to be 'local', having low latency.
533
 
 
534
 
        :returns: PullResult instance
535
 
        """
536
 
        raise NotImplementedError(self.pull)
537
 
 
538
 
    def push(self, target, overwrite=False, stop_revision=None):
539
 
        """Mirror this branch into target.
540
 
 
541
 
        This branch is considered to be 'local', having low latency.
542
 
        """
543
 
        raise NotImplementedError(self.push)
 
404
    def revision_tree(self, revision_id):
 
405
        """Return Tree for a revision on this branch.
 
406
 
 
407
        `revision_id` may be None for the null revision, in which case
 
408
        an `EmptyTree` is returned."""
 
409
        raise NotImplementedError('revision_tree is abstract')
 
410
 
 
411
    def working_tree(self):
 
412
        """Return a `Tree` for the working copy if this is a local branch."""
 
413
        raise NotImplementedError('working_tree is abstract')
 
414
 
 
415
    def pull(self, source, overwrite=False):
 
416
        raise NotImplementedError('pull is abstract')
544
417
 
545
418
    def basis_tree(self):
546
 
        """Return `Tree` object for last revision."""
547
 
        return self.repository.revision_tree(self.last_revision())
 
419
        """Return `Tree` object for last revision.
 
420
 
 
421
        If there are no revisions yet, return an `EmptyTree`.
 
422
        """
 
423
        return self.revision_tree(self.last_revision())
548
424
 
549
425
    def rename_one(self, from_rel, to_rel):
550
426
        """Rename one file.
551
427
 
552
428
        This can change the directory or the filename or both.
553
429
        """
554
 
        raise NotImplementedError(self.rename_one)
 
430
        raise NotImplementedError('rename_one is abstract')
555
431
 
556
432
    def move(self, from_paths, to_name):
557
433
        """Rename files.
567
443
        This returns a list of (from_path, to_path) pairs for each
568
444
        entry that is moved.
569
445
        """
570
 
        raise NotImplementedError(self.move)
 
446
        raise NotImplementedError('move is abstract')
571
447
 
572
448
    def get_parent(self):
573
449
        """Return the parent location of the branch.
576
452
        pattern is that the user can override it by specifying a
577
453
        location.
578
454
        """
579
 
        raise NotImplementedError(self.get_parent)
580
 
 
581
 
    def _set_config_location(self, name, url, config=None,
582
 
                             make_relative=False):
583
 
        if config is None:
584
 
            config = self.get_config()
585
 
        if url is None:
586
 
            url = ''
587
 
        elif make_relative:
588
 
            url = urlutils.relative_url(self.base, url)
589
 
        config.set_user_option(name, url)
590
 
 
591
 
    def _get_config_location(self, name, config=None):
592
 
        if config is None:
593
 
            config = self.get_config()
594
 
        location = config.get_user_option(name)
595
 
        if location == '':
596
 
            location = None
597
 
        return location
598
 
 
599
 
    def get_submit_branch(self):
600
 
        """Return the submit location of the branch.
601
 
 
602
 
        This is the default location for bundle.  The usual
603
 
        pattern is that the user can override it by specifying a
604
 
        location.
605
 
        """
606
 
        return self.get_config().get_user_option('submit_branch')
607
 
 
608
 
    def set_submit_branch(self, location):
609
 
        """Return the submit location of the branch.
610
 
 
611
 
        This is the default location for bundle.  The usual
612
 
        pattern is that the user can override it by specifying a
613
 
        location.
614
 
        """
615
 
        self.get_config().set_user_option('submit_branch', location)
616
 
 
617
 
    def get_public_branch(self):
618
 
        """Return the public location of the branch.
619
 
 
620
 
        This is is used by merge directives.
621
 
        """
622
 
        return self._get_config_location('public_branch')
623
 
 
624
 
    def set_public_branch(self, location):
625
 
        """Return the submit location of the branch.
626
 
 
627
 
        This is the default location for bundle.  The usual
628
 
        pattern is that the user can override it by specifying a
629
 
        location.
630
 
        """
631
 
        self._set_config_location('public_branch', location)
 
455
        raise NotImplementedError('get_parent is abstract')
632
456
 
633
457
    def get_push_location(self):
634
458
        """Return the None or the location to push this branch to."""
635
 
        push_loc = self.get_config().get_user_option('push_location')
636
 
        return push_loc
 
459
        raise NotImplementedError('get_push_location is abstract')
637
460
 
638
461
    def set_push_location(self, location):
639
462
        """Set a new push location for this branch."""
640
 
        raise NotImplementedError(self.set_push_location)
 
463
        raise NotImplementedError('set_push_location is abstract')
641
464
 
642
465
    def set_parent(self, url):
643
 
        raise NotImplementedError(self.set_parent)
644
 
 
645
 
    @needs_write_lock
646
 
    def update(self):
647
 
        """Synchronise this branch with the master branch if any. 
648
 
 
649
 
        :return: None or the last_revision pivoted out during the update.
650
 
        """
651
 
        return None
 
466
        raise NotImplementedError('set_parent is abstract')
652
467
 
653
468
    def check_revno(self, revno):
654
469
        """\
665
480
        """
666
481
        if revno < 1 or revno > self.revno():
667
482
            raise InvalidRevisionNumber(revno)
668
 
 
669
 
    @needs_read_lock
670
 
    def clone(self, to_bzrdir, revision_id=None):
671
 
        """Clone this branch into to_bzrdir preserving all semantic values.
672
 
        
673
 
        revision_id: if not None, the revision history in the new branch will
674
 
                     be truncated to end with revision_id.
675
 
        """
676
 
        result = self._format.initialize(to_bzrdir)
677
 
        self.copy_content_into(result, revision_id=revision_id)
678
 
        return  result
679
 
 
680
 
    @needs_read_lock
681
 
    def sprout(self, to_bzrdir, revision_id=None):
682
 
        """Create a new line of development from the branch, into to_bzrdir.
683
 
        
684
 
        revision_id: if not None, the revision history in the new branch will
685
 
                     be truncated to end with revision_id.
686
 
        """
687
 
        result = self._format.initialize(to_bzrdir)
688
 
        self.copy_content_into(result, revision_id=revision_id)
689
 
        result.set_parent(self.bzrdir.root_transport.base)
690
 
        return result
691
 
 
692
 
    def _synchronize_history(self, destination, revision_id):
693
 
        """Synchronize last revision and revision history between branches.
694
 
 
695
 
        This version is most efficient when the destination is also a
696
 
        BzrBranch5, but works for BzrBranch6 as long as the revision
697
 
        history is the true lefthand parent history, and all of the revisions
698
 
        are in the destination's repository.  If not, set_revision_history
699
 
        will fail.
700
 
 
701
 
        :param destination: The branch to copy the history into
702
 
        :param revision_id: The revision-id to truncate history at.  May
703
 
          be None to copy complete history.
704
 
        """
705
 
        new_history = self.revision_history()
706
 
        if revision_id is not None:
707
 
            revision_id = osutils.safe_revision_id(revision_id)
708
 
            try:
709
 
                new_history = new_history[:new_history.index(revision_id) + 1]
710
 
            except ValueError:
711
 
                rev = self.repository.get_revision(revision_id)
712
 
                new_history = rev.get_history(self.repository)[1:]
713
 
        destination.set_revision_history(new_history)
714
 
 
715
 
    @needs_read_lock
716
 
    def copy_content_into(self, destination, revision_id=None):
717
 
        """Copy the content of self into destination.
718
 
 
719
 
        revision_id: if not None, the revision history in the new branch will
720
 
                     be truncated to end with revision_id.
721
 
        """
722
 
        self._synchronize_history(destination, revision_id)
723
 
        try:
724
 
            parent = self.get_parent()
725
 
        except errors.InaccessibleParent, e:
726
 
            mutter('parent was not accessible to copy: %s', e)
727
 
        else:
728
 
            if parent:
729
 
                destination.set_parent(parent)
730
 
        self.tags.merge_to(destination.tags)
731
 
 
732
 
    @needs_read_lock
733
 
    def check(self):
734
 
        """Check consistency of the branch.
735
 
 
736
 
        In particular this checks that revisions given in the revision-history
737
 
        do actually match up in the revision graph, and that they're all 
738
 
        present in the repository.
739
 
        
740
 
        Callers will typically also want to check the repository.
741
 
 
742
 
        :return: A BranchCheckResult.
743
 
        """
744
 
        mainline_parent_id = None
745
 
        for revision_id in self.revision_history():
746
 
            try:
747
 
                revision = self.repository.get_revision(revision_id)
748
 
            except errors.NoSuchRevision, e:
749
 
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
750
 
                            % revision_id)
751
 
            # In general the first entry on the revision history has no parents.
752
 
            # But it's not illegal for it to have parents listed; this can happen
753
 
            # in imports from Arch when the parents weren't reachable.
754
 
            if mainline_parent_id is not None:
755
 
                if mainline_parent_id not in revision.parent_ids:
756
 
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
757
 
                                        "parents of {%s}"
758
 
                                        % (mainline_parent_id, revision_id))
759
 
            mainline_parent_id = revision_id
760
 
        return BranchCheckResult(self)
761
 
 
762
 
    def _get_checkout_format(self):
763
 
        """Return the most suitable metadir for a checkout of this branch.
764
 
        Weaves are used if this branch's repository uses weaves.
765
 
        """
766
 
        if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
767
 
            from bzrlib.repofmt import weaverepo
768
 
            format = bzrdir.BzrDirMetaFormat1()
769
 
            format.repository_format = weaverepo.RepositoryFormat7()
770
 
        else:
771
 
            format = self.repository.bzrdir.checkout_metadir()
772
 
            format.set_branch_format(self._format)
773
 
        return format
774
 
 
775
 
    def create_checkout(self, to_location, revision_id=None,
776
 
                        lightweight=False):
777
 
        """Create a checkout of a branch.
778
 
        
779
 
        :param to_location: The url to produce the checkout at
780
 
        :param revision_id: The revision to check out
781
 
        :param lightweight: If True, produce a lightweight checkout, otherwise,
782
 
        produce a bound branch (heavyweight checkout)
783
 
        :return: The tree of the created checkout
784
 
        """
785
 
        t = transport.get_transport(to_location)
786
 
        t.ensure_base()
787
 
        if lightweight:
788
 
            format = self._get_checkout_format()
789
 
            checkout = format.initialize_on_transport(t)
790
 
            BranchReferenceFormat().initialize(checkout, self)
791
 
        else:
792
 
            format = self._get_checkout_format()
793
 
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
794
 
                to_location, force_new_tree=False, format=format)
795
 
            checkout = checkout_branch.bzrdir
796
 
            checkout_branch.bind(self)
797
 
            # pull up to the specified revision_id to set the initial 
798
 
            # branch tip correctly, and seed it with history.
799
 
            checkout_branch.pull(self, stop_revision=revision_id)
800
 
        tree = checkout.create_workingtree(revision_id)
801
 
        basis_tree = tree.basis_tree()
802
 
        basis_tree.lock_read()
803
 
        try:
804
 
            for path, file_id in basis_tree.iter_references():
805
 
                reference_parent = self.reference_parent(file_id, path)
806
 
                reference_parent.create_checkout(tree.abspath(path),
807
 
                    basis_tree.get_reference_revision(file_id, path),
808
 
                    lightweight)
809
 
        finally:
810
 
            basis_tree.unlock()
811
 
        return tree
812
 
 
813
 
    def reference_parent(self, file_id, path):
814
 
        """Return the parent branch for a tree-reference file_id
815
 
        :param file_id: The file_id of the tree reference
816
 
        :param path: The path of the file_id in the tree
817
 
        :return: A branch associated with the file_id
818
 
        """
819
 
        # FIXME should provide multiple branches, based on config
820
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
821
 
 
822
 
    def supports_tags(self):
823
 
        return self._format.supports_tags()
824
 
 
825
 
 
826
 
class BranchFormat(object):
827
 
    """An encapsulation of the initialization and open routines for a format.
828
 
 
829
 
    Formats provide three things:
830
 
     * An initialization routine,
831
 
     * a format string,
832
 
     * an open routine.
833
 
 
834
 
    Formats are placed in an dict by their format string for reference 
835
 
    during branch opening. Its not required that these be instances, they
836
 
    can be classes themselves with class methods - it simply depends on 
837
 
    whether state is needed for a given format or not.
838
 
 
839
 
    Once a format is deprecated, just deprecate the initialize and open
840
 
    methods on the format class. Do not deprecate the object, as the 
841
 
    object will be created every time regardless.
842
 
    """
843
 
 
844
 
    _default_format = None
845
 
    """The default format used for new branches."""
846
 
 
847
 
    _formats = {}
848
 
    """The known formats."""
849
 
 
850
 
    @classmethod
851
 
    def find_format(klass, a_bzrdir):
852
 
        """Return the format for the branch object in a_bzrdir."""
853
 
        try:
854
 
            transport = a_bzrdir.get_branch_transport(None)
855
 
            format_string = transport.get("format").read()
856
 
            return klass._formats[format_string]
857
 
        except NoSuchFile:
858
 
            raise NotBranchError(path=transport.base)
859
 
        except KeyError:
860
 
            raise errors.UnknownFormatError(format=format_string)
861
 
 
862
 
    @classmethod
863
 
    def get_default_format(klass):
864
 
        """Return the current default format."""
865
 
        return klass._default_format
866
 
 
867
 
    def get_reference(self, a_bzrdir):
868
 
        """Get the target reference of the branch in a_bzrdir.
869
 
 
870
 
        format probing must have been completed before calling
871
 
        this method - it is assumed that the format of the branch
872
 
        in a_bzrdir is correct.
873
 
 
874
 
        :param a_bzrdir: The bzrdir to get the branch data from.
875
 
        :return: None if the branch is not a reference branch.
876
 
        """
877
 
        return None
878
 
 
879
 
    def get_format_string(self):
880
 
        """Return the ASCII format string that identifies this format."""
881
 
        raise NotImplementedError(self.get_format_string)
882
 
 
883
 
    def get_format_description(self):
884
 
        """Return the short format description for this format."""
885
 
        raise NotImplementedError(self.get_format_description)
886
 
 
887
 
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
888
 
                           set_format=True):
889
 
        """Initialize a branch in a bzrdir, with specified files
890
 
 
891
 
        :param a_bzrdir: The bzrdir to initialize the branch in
892
 
        :param utf8_files: The files to create as a list of
893
 
            (filename, content) tuples
894
 
        :param set_format: If True, set the format with
895
 
            self.get_format_string.  (BzrBranch4 has its format set
896
 
            elsewhere)
897
 
        :return: a branch in this format
898
 
        """
899
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
900
 
        branch_transport = a_bzrdir.get_branch_transport(self)
901
 
        lock_map = {
902
 
            'metadir': ('lock', lockdir.LockDir),
903
 
            'branch4': ('branch-lock', lockable_files.TransportLock),
904
 
        }
905
 
        lock_name, lock_class = lock_map[lock_type]
906
 
        control_files = lockable_files.LockableFiles(branch_transport,
907
 
            lock_name, lock_class)
908
 
        control_files.create_lock()
909
 
        control_files.lock_write()
910
 
        if set_format:
911
 
            control_files.put_utf8('format', self.get_format_string())
912
 
        try:
913
 
            for file, content in utf8_files:
914
 
                control_files.put_utf8(file, content)
915
 
        finally:
916
 
            control_files.unlock()
917
 
        return self.open(a_bzrdir, _found=True)
918
 
 
919
 
    def initialize(self, a_bzrdir):
920
 
        """Create a branch of this format in a_bzrdir."""
921
 
        raise NotImplementedError(self.initialize)
922
 
 
923
 
    def is_supported(self):
924
 
        """Is this format supported?
925
 
 
926
 
        Supported formats can be initialized and opened.
927
 
        Unsupported formats may not support initialization or committing or 
928
 
        some other features depending on the reason for not being supported.
929
 
        """
930
 
        return True
931
 
 
932
 
    def open(self, a_bzrdir, _found=False):
933
 
        """Return the branch object for a_bzrdir
934
 
 
935
 
        _found is a private parameter, do not use it. It is used to indicate
936
 
               if format probing has already be done.
937
 
        """
938
 
        raise NotImplementedError(self.open)
939
 
 
940
 
    @classmethod
941
 
    def register_format(klass, format):
942
 
        klass._formats[format.get_format_string()] = format
943
 
 
944
 
    @classmethod
945
 
    def set_default_format(klass, format):
946
 
        klass._default_format = format
947
 
 
948
 
    @classmethod
949
 
    def unregister_format(klass, format):
950
 
        assert klass._formats[format.get_format_string()] is format
951
 
        del klass._formats[format.get_format_string()]
952
 
 
953
 
    def __str__(self):
954
 
        return self.get_format_string().rstrip()
955
 
 
956
 
    def supports_tags(self):
957
 
        """True if this format supports tags stored in the branch"""
958
 
        return False  # by default
959
 
 
960
 
    # XXX: Probably doesn't really belong here -- mbp 20070212
961
 
    def _initialize_control_files(self, a_bzrdir, utf8_files, lock_filename,
962
 
            lock_class):
963
 
        branch_transport = a_bzrdir.get_branch_transport(self)
964
 
        control_files = lockable_files.LockableFiles(branch_transport,
965
 
            lock_filename, lock_class)
966
 
        control_files.create_lock()
967
 
        control_files.lock_write()
968
 
        try:
969
 
            for filename, content in utf8_files:
970
 
                control_files.put_utf8(filename, content)
971
 
        finally:
972
 
            control_files.unlock()
973
 
 
974
 
 
975
 
class BranchHooks(Hooks):
976
 
    """A dictionary mapping hook name to a list of callables for branch hooks.
977
 
    
978
 
    e.g. ['set_rh'] Is the list of items to be called when the
979
 
    set_revision_history function is invoked.
980
 
    """
981
 
 
982
 
    def __init__(self):
983
 
        """Create the default hooks.
984
 
 
985
 
        These are all empty initially, because by default nothing should get
986
 
        notified.
987
 
        """
988
 
        Hooks.__init__(self)
989
 
        # Introduced in 0.15:
990
 
        # invoked whenever the revision history has been set
991
 
        # with set_revision_history. The api signature is
992
 
        # (branch, revision_history), and the branch will
993
 
        # be write-locked.
994
 
        self['set_rh'] = []
995
 
        # invoked after a push operation completes.
996
 
        # the api signature is
997
 
        # (push_result)
998
 
        # containing the members
999
 
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
1000
 
        # where local is the local target branch or None, master is the target 
1001
 
        # master branch, and the rest should be self explanatory. The source
1002
 
        # is read locked and the target branches write locked. Source will
1003
 
        # be the local low-latency branch.
1004
 
        self['post_push'] = []
1005
 
        # invoked after a pull operation completes.
1006
 
        # the api signature is
1007
 
        # (pull_result)
1008
 
        # containing the members
1009
 
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
1010
 
        # where local is the local branch or None, master is the target 
1011
 
        # master branch, and the rest should be self explanatory. The source
1012
 
        # is read locked and the target branches write locked. The local
1013
 
        # branch is the low-latency branch.
1014
 
        self['post_pull'] = []
1015
 
        # invoked after a commit operation completes.
1016
 
        # the api signature is 
1017
 
        # (local, master, old_revno, old_revid, new_revno, new_revid)
1018
 
        # old_revid is NULL_REVISION for the first commit to a branch.
1019
 
        self['post_commit'] = []
1020
 
        # invoked after a uncommit operation completes.
1021
 
        # the api signature is
1022
 
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
1023
 
        # local is the local branch or None, master is the target branch,
1024
 
        # and an empty branch recieves new_revno of 0, new_revid of None.
1025
 
        self['post_uncommit'] = []
1026
 
 
1027
 
 
1028
 
# install the default hooks into the Branch class.
1029
 
Branch.hooks = BranchHooks()
1030
 
 
1031
 
 
1032
 
class BzrBranchFormat4(BranchFormat):
1033
 
    """Bzr branch format 4.
1034
 
 
1035
 
    This format has:
1036
 
     - a revision-history file.
1037
 
     - a branch-lock lock file [ to be shared with the bzrdir ]
1038
 
    """
1039
 
 
1040
 
    def get_format_description(self):
1041
 
        """See BranchFormat.get_format_description()."""
1042
 
        return "Branch format 4"
1043
 
 
1044
 
    def initialize(self, a_bzrdir):
1045
 
        """Create a branch of this format in a_bzrdir."""
1046
 
        utf8_files = [('revision-history', ''),
1047
 
                      ('branch-name', ''),
1048
 
                      ]
1049
 
        return self._initialize_helper(a_bzrdir, utf8_files,
1050
 
                                       lock_type='branch4', set_format=False)
1051
 
 
1052
 
    def __init__(self):
1053
 
        super(BzrBranchFormat4, self).__init__()
1054
 
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
1055
 
 
1056
 
    def open(self, a_bzrdir, _found=False):
1057
 
        """Return the branch object for a_bzrdir
1058
 
 
1059
 
        _found is a private parameter, do not use it. It is used to indicate
1060
 
               if format probing has already be done.
1061
 
        """
1062
 
        if not _found:
1063
 
            # we are being called directly and must probe.
1064
 
            raise NotImplementedError
1065
 
        return BzrBranch(_format=self,
1066
 
                         _control_files=a_bzrdir._control_files,
1067
 
                         a_bzrdir=a_bzrdir,
1068
 
                         _repository=a_bzrdir.open_repository())
1069
 
 
1070
 
    def __str__(self):
1071
 
        return "Bazaar-NG branch format 4"
1072
 
 
1073
 
 
1074
 
class BzrBranchFormat5(BranchFormat):
1075
 
    """Bzr branch format 5.
1076
 
 
1077
 
    This format has:
1078
 
     - a revision-history file.
1079
 
     - a format string
1080
 
     - a lock dir guarding the branch itself
1081
 
     - all of this stored in a branch/ subdirectory
1082
 
     - works with shared repositories.
1083
 
 
1084
 
    This format is new in bzr 0.8.
1085
 
    """
1086
 
 
1087
 
    def get_format_string(self):
1088
 
        """See BranchFormat.get_format_string()."""
1089
 
        return "Bazaar-NG branch format 5\n"
1090
 
 
1091
 
    def get_format_description(self):
1092
 
        """See BranchFormat.get_format_description()."""
1093
 
        return "Branch format 5"
1094
 
        
1095
 
    def initialize(self, a_bzrdir):
1096
 
        """Create a branch of this format in a_bzrdir."""
1097
 
        utf8_files = [('revision-history', ''),
1098
 
                      ('branch-name', ''),
1099
 
                      ]
1100
 
        return self._initialize_helper(a_bzrdir, utf8_files)
1101
 
 
1102
 
    def __init__(self):
1103
 
        super(BzrBranchFormat5, self).__init__()
1104
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1105
 
 
1106
 
    def open(self, a_bzrdir, _found=False):
1107
 
        """Return the branch object for a_bzrdir
1108
 
 
1109
 
        _found is a private parameter, do not use it. It is used to indicate
1110
 
               if format probing has already be done.
1111
 
        """
1112
 
        if not _found:
1113
 
            format = BranchFormat.find_format(a_bzrdir)
1114
 
            assert format.__class__ == self.__class__
1115
 
        try:
1116
 
            transport = a_bzrdir.get_branch_transport(None)
1117
 
            control_files = lockable_files.LockableFiles(transport, 'lock',
1118
 
                                                         lockdir.LockDir)
1119
 
            return BzrBranch5(_format=self,
1120
 
                              _control_files=control_files,
1121
 
                              a_bzrdir=a_bzrdir,
1122
 
                              _repository=a_bzrdir.find_repository())
1123
 
        except NoSuchFile:
1124
 
            raise NotBranchError(path=transport.base)
1125
 
 
1126
 
 
1127
 
class BzrBranchFormat6(BzrBranchFormat5):
1128
 
    """Branch format with last-revision
1129
 
 
1130
 
    Unlike previous formats, this has no explicit revision history. Instead,
1131
 
    this just stores the last-revision, and the left-hand history leading
1132
 
    up to there is the history.
1133
 
 
1134
 
    This format was introduced in bzr 0.15
1135
 
    """
1136
 
 
1137
 
    def get_format_string(self):
1138
 
        """See BranchFormat.get_format_string()."""
1139
 
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
1140
 
 
1141
 
    def get_format_description(self):
1142
 
        """See BranchFormat.get_format_description()."""
1143
 
        return "Branch format 6"
1144
 
 
1145
 
    def initialize(self, a_bzrdir):
1146
 
        """Create a branch of this format in a_bzrdir."""
1147
 
        utf8_files = [('last-revision', '0 null:\n'),
1148
 
                      ('branch-name', ''),
1149
 
                      ('branch.conf', ''),
1150
 
                      ('tags', ''),
1151
 
                      ]
1152
 
        return self._initialize_helper(a_bzrdir, utf8_files)
1153
 
 
1154
 
    def open(self, a_bzrdir, _found=False):
1155
 
        """Return the branch object for a_bzrdir
1156
 
 
1157
 
        _found is a private parameter, do not use it. It is used to indicate
1158
 
               if format probing has already be done.
1159
 
        """
1160
 
        if not _found:
1161
 
            format = BranchFormat.find_format(a_bzrdir)
1162
 
            assert format.__class__ == self.__class__
1163
 
        transport = a_bzrdir.get_branch_transport(None)
1164
 
        control_files = lockable_files.LockableFiles(transport, 'lock',
1165
 
                                                     lockdir.LockDir)
1166
 
        return BzrBranch6(_format=self,
1167
 
                          _control_files=control_files,
1168
 
                          a_bzrdir=a_bzrdir,
1169
 
                          _repository=a_bzrdir.find_repository())
1170
 
 
1171
 
    def supports_tags(self):
1172
 
        return True
1173
 
 
1174
 
 
1175
 
class BranchReferenceFormat(BranchFormat):
1176
 
    """Bzr branch reference format.
1177
 
 
1178
 
    Branch references are used in implementing checkouts, they
1179
 
    act as an alias to the real branch which is at some other url.
1180
 
 
1181
 
    This format has:
1182
 
     - A location file
1183
 
     - a format string
1184
 
    """
1185
 
 
1186
 
    def get_format_string(self):
1187
 
        """See BranchFormat.get_format_string()."""
1188
 
        return "Bazaar-NG Branch Reference Format 1\n"
1189
 
 
1190
 
    def get_format_description(self):
1191
 
        """See BranchFormat.get_format_description()."""
1192
 
        return "Checkout reference format 1"
1193
 
        
1194
 
    def get_reference(self, a_bzrdir):
1195
 
        """See BranchFormat.get_reference()."""
1196
 
        transport = a_bzrdir.get_branch_transport(None)
1197
 
        return transport.get('location').read()
1198
 
 
1199
 
    def initialize(self, a_bzrdir, target_branch=None):
1200
 
        """Create a branch of this format in a_bzrdir."""
1201
 
        if target_branch is None:
1202
 
            # this format does not implement branch itself, thus the implicit
1203
 
            # creation contract must see it as uninitializable
1204
 
            raise errors.UninitializableFormat(self)
1205
 
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
1206
 
        branch_transport = a_bzrdir.get_branch_transport(self)
1207
 
        branch_transport.put_bytes('location',
1208
 
            target_branch.bzrdir.root_transport.base)
1209
 
        branch_transport.put_bytes('format', self.get_format_string())
1210
 
        return self.open(a_bzrdir, _found=True)
1211
 
 
1212
 
    def __init__(self):
1213
 
        super(BranchReferenceFormat, self).__init__()
1214
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1215
 
 
1216
 
    def _make_reference_clone_function(format, a_branch):
1217
 
        """Create a clone() routine for a branch dynamically."""
1218
 
        def clone(to_bzrdir, revision_id=None):
1219
 
            """See Branch.clone()."""
1220
 
            return format.initialize(to_bzrdir, a_branch)
1221
 
            # cannot obey revision_id limits when cloning a reference ...
1222
 
            # FIXME RBC 20060210 either nuke revision_id for clone, or
1223
 
            # emit some sort of warning/error to the caller ?!
1224
 
        return clone
1225
 
 
1226
 
    def open(self, a_bzrdir, _found=False, location=None):
1227
 
        """Return the branch that the branch reference in a_bzrdir points at.
1228
 
 
1229
 
        _found is a private parameter, do not use it. It is used to indicate
1230
 
               if format probing has already be done.
1231
 
        """
1232
 
        if not _found:
1233
 
            format = BranchFormat.find_format(a_bzrdir)
1234
 
            assert format.__class__ == self.__class__
1235
 
        if location is None:
1236
 
            location = self.get_reference(a_bzrdir)
1237
 
        real_bzrdir = bzrdir.BzrDir.open(location)
1238
 
        result = real_bzrdir.open_branch()
1239
 
        # this changes the behaviour of result.clone to create a new reference
1240
 
        # rather than a copy of the content of the branch.
1241
 
        # I did not use a proxy object because that needs much more extensive
1242
 
        # testing, and we are only changing one behaviour at the moment.
1243
 
        # If we decide to alter more behaviours - i.e. the implicit nickname
1244
 
        # then this should be refactored to introduce a tested proxy branch
1245
 
        # and a subclass of that for use in overriding clone() and ....
1246
 
        # - RBC 20060210
1247
 
        result.clone = self._make_reference_clone_function(result)
1248
 
        return result
1249
 
 
1250
 
 
1251
 
# formats which have no format string are not discoverable
1252
 
# and not independently creatable, so are not registered.
1253
 
__default_format = BzrBranchFormat5()
1254
 
BranchFormat.register_format(__default_format)
1255
 
BranchFormat.register_format(BranchReferenceFormat())
1256
 
BranchFormat.register_format(BzrBranchFormat6())
1257
 
BranchFormat.set_default_format(__default_format)
1258
 
_legacy_formats = [BzrBranchFormat4(),
1259
 
                   ]
 
483
        
 
484
    def sign_revision(self, revision_id, gpg_strategy):
 
485
        raise NotImplementedError('sign_revision is abstract')
 
486
 
 
487
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
488
        raise NotImplementedError('store_revision_signature is abstract')
1260
489
 
1261
490
class BzrBranch(Branch):
1262
491
    """A branch stored in the actual filesystem.
1264
493
    Note that it's "local" in the context of the filesystem; it doesn't
1265
494
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
1266
495
    it's writable, and can be accessed via the normal filesystem API.
 
496
 
 
497
    _lock_mode
 
498
        None, or 'r' or 'w'
 
499
 
 
500
    _lock_count
 
501
        If _lock_mode is true, a positive count of the number of times the
 
502
        lock has been taken.
 
503
 
 
504
    _lock
 
505
        Lock object from bzrlib.lock.
1267
506
    """
 
507
    # We actually expect this class to be somewhat short-lived; part of its
 
508
    # purpose is to try to isolate what bits of the branch logic are tied to
 
509
    # filesystem access, so that in a later step, we can extricate them to
 
510
    # a separarte ("storage") class.
 
511
    _lock_mode = None
 
512
    _lock_count = None
 
513
    _lock = None
 
514
    _inventory_weave = None
1268
515
    
1269
 
    def __init__(self, _format=None,
1270
 
                 _control_files=None, a_bzrdir=None, _repository=None):
1271
 
        """Create new branch object at a particular location."""
1272
 
        Branch.__init__(self)
1273
 
        if a_bzrdir is None:
1274
 
            raise ValueError('a_bzrdir must be supplied')
1275
 
        else:
1276
 
            self.bzrdir = a_bzrdir
1277
 
        # self._transport used to point to the directory containing the
1278
 
        # control directory, but was not used - now it's just the transport
1279
 
        # for the branch control files.  mbp 20070212
1280
 
        self._base = self.bzrdir.transport.clone('..').base
1281
 
        self._format = _format
1282
 
        if _control_files is None:
1283
 
            raise ValueError('BzrBranch _control_files is None')
1284
 
        self.control_files = _control_files
1285
 
        self._transport = _control_files._transport
1286
 
        self.repository = _repository
 
516
    # Map some sort of prefix into a namespace
 
517
    # stuff like "revno:10", "revid:", etc.
 
518
    # This should match a prefix with a function which accepts
 
519
    REVISION_NAMESPACES = {}
 
520
 
 
521
    def push_stores(self, branch_to):
 
522
        """See Branch.push_stores."""
 
523
        if (self._branch_format != branch_to._branch_format
 
524
            or self._branch_format != 4):
 
525
            from bzrlib.fetch import greedy_fetch
 
526
            mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
 
527
                   self, self._branch_format, branch_to, branch_to._branch_format)
 
528
            greedy_fetch(to_branch=branch_to, from_branch=self,
 
529
                         revision=self.last_revision())
 
530
            return
 
531
 
 
532
        store_pairs = ((self.text_store,      branch_to.text_store),
 
533
                       (self.inventory_store, branch_to.inventory_store),
 
534
                       (self.revision_store,  branch_to.revision_store))
 
535
        try:
 
536
            for from_store, to_store in store_pairs: 
 
537
                copy_all(from_store, to_store)
 
538
        except UnlistableStore:
 
539
            raise UnlistableBranch(from_store)
 
540
 
 
541
    def __init__(self, transport, init=False,
 
542
                 relax_version_check=False):
 
543
        """Create new branch object at a particular location.
 
544
 
 
545
        transport -- A Transport object, defining how to access files.
 
546
        
 
547
        init -- If True, create new control files in a previously
 
548
             unversioned directory.  If False, the branch must already
 
549
             be versioned.
 
550
 
 
551
        relax_version_check -- If true, the usual check for the branch
 
552
            version is not applied.  This is intended only for
 
553
            upgrade/recovery type use; it's not guaranteed that
 
554
            all operations will work on old format branches.
 
555
 
 
556
        In the test suite, creation of new trees is tested using the
 
557
        `ScratchBranch` class.
 
558
        """
 
559
        assert isinstance(transport, Transport), \
 
560
            "%r is not a Transport" % transport
 
561
        self._transport = transport
 
562
        if init:
 
563
            self._make_control()
 
564
        self._check_format(relax_version_check)
 
565
 
 
566
        def get_store(name, compressed=True, prefixed=False):
 
567
            # FIXME: This approach of assuming stores are all entirely compressed
 
568
            # or entirely uncompressed is tidy, but breaks upgrade from 
 
569
            # some existing branches where there's a mixture; we probably 
 
570
            # still want the option to look for both.
 
571
            relpath = self._rel_controlfilename(name)
 
572
            store = TextStore(self._transport.clone(relpath),
 
573
                              prefixed=prefixed,
 
574
                              compressed=compressed)
 
575
            #if self._transport.should_cache():
 
576
            #    cache_path = os.path.join(self.cache_root, name)
 
577
            #    os.mkdir(cache_path)
 
578
            #    store = bzrlib.store.CachedStore(store, cache_path)
 
579
            return store
 
580
        def get_weave(name, prefixed=False):
 
581
            relpath = self._rel_controlfilename(name)
 
582
            ws = WeaveStore(self._transport.clone(relpath), prefixed=prefixed)
 
583
            if self._transport.should_cache():
 
584
                ws.enable_cache = True
 
585
            return ws
 
586
 
 
587
        if self._branch_format == 4:
 
588
            self.inventory_store = get_store(u'inventory-store')
 
589
            self.text_store = get_store(u'text-store')
 
590
            self.revision_store = get_store(u'revision-store')
 
591
        elif self._branch_format == 5:
 
592
            self.control_weaves = get_weave(u'')
 
593
            self.weave_store = get_weave(u'weaves')
 
594
            self.revision_store = get_store(u'revision-store', compressed=False)
 
595
        elif self._branch_format == 6:
 
596
            self.control_weaves = get_weave(u'')
 
597
            self.weave_store = get_weave(u'weaves', prefixed=True)
 
598
            self.revision_store = get_store(u'revision-store', compressed=False,
 
599
                                            prefixed=True)
 
600
        self.revision_store.register_suffix('sig')
 
601
        self._transaction = None
1287
602
 
1288
603
    def __str__(self):
1289
 
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
604
        return '%s(%r)' % (self.__class__.__name__, self._transport.base)
1290
605
 
1291
606
    __repr__ = __str__
1292
607
 
 
608
    def __del__(self):
 
609
        if self._lock_mode or self._lock:
 
610
            # XXX: This should show something every time, and be suitable for
 
611
            # headless operation and embedding
 
612
            warn("branch %r was not explicitly unlocked" % self)
 
613
            self._lock.unlock()
 
614
 
 
615
        # TODO: It might be best to do this somewhere else,
 
616
        # but it is nice for a Branch object to automatically
 
617
        # cache it's information.
 
618
        # Alternatively, we could have the Transport objects cache requests
 
619
        # See the earlier discussion about how major objects (like Branch)
 
620
        # should never expect their __del__ function to run.
 
621
        if hasattr(self, 'cache_root') and self.cache_root is not None:
 
622
            try:
 
623
                shutil.rmtree(self.cache_root)
 
624
            except:
 
625
                pass
 
626
            self.cache_root = None
 
627
 
1293
628
    def _get_base(self):
1294
 
        """Returns the directory containing the control directory."""
1295
 
        return self._base
 
629
        if self._transport:
 
630
            return self._transport.base
 
631
        return None
1296
632
 
1297
633
    base = property(_get_base, doc="The URL for the root of this branch.")
1298
634
 
 
635
    def _finish_transaction(self):
 
636
        """Exit the current transaction."""
 
637
        if self._transaction is None:
 
638
            raise errors.LockError('Branch %s is not in a transaction' %
 
639
                                   self)
 
640
        transaction = self._transaction
 
641
        self._transaction = None
 
642
        transaction.finish()
 
643
 
 
644
    def get_transaction(self):
 
645
        """See Branch.get_transaction."""
 
646
        if self._transaction is None:
 
647
            return transactions.PassThroughTransaction()
 
648
        else:
 
649
            return self._transaction
 
650
 
 
651
    def _set_transaction(self, new_transaction):
 
652
        """Set a new active transaction."""
 
653
        if self._transaction is not None:
 
654
            raise errors.LockError('Branch %s is in a transaction already.' %
 
655
                                   self)
 
656
        self._transaction = new_transaction
 
657
 
 
658
    def lock_write(self):
 
659
        mutter("lock write: %s (%s)", self, self._lock_count)
 
660
        # TODO: Upgrade locking to support using a Transport,
 
661
        # and potentially a remote locking protocol
 
662
        if self._lock_mode:
 
663
            if self._lock_mode != 'w':
 
664
                raise LockError("can't upgrade to a write lock from %r" %
 
665
                                self._lock_mode)
 
666
            self._lock_count += 1
 
667
        else:
 
668
            self._lock = self._transport.lock_write(
 
669
                    self._rel_controlfilename('branch-lock'))
 
670
            self._lock_mode = 'w'
 
671
            self._lock_count = 1
 
672
            self._set_transaction(transactions.PassThroughTransaction())
 
673
 
 
674
    def lock_read(self):
 
675
        mutter("lock read: %s (%s)", self, self._lock_count)
 
676
        if self._lock_mode:
 
677
            assert self._lock_mode in ('r', 'w'), \
 
678
                   "invalid lock mode %r" % self._lock_mode
 
679
            self._lock_count += 1
 
680
        else:
 
681
            self._lock = self._transport.lock_read(
 
682
                    self._rel_controlfilename('branch-lock'))
 
683
            self._lock_mode = 'r'
 
684
            self._lock_count = 1
 
685
            self._set_transaction(transactions.ReadOnlyTransaction())
 
686
            # 5K may be excessive, but hey, its a knob.
 
687
            self.get_transaction().set_cache_size(5000)
 
688
                        
 
689
    def unlock(self):
 
690
        mutter("unlock: %s (%s)", self, self._lock_count)
 
691
        if not self._lock_mode:
 
692
            raise LockError('branch %r is not locked' % (self))
 
693
 
 
694
        if self._lock_count > 1:
 
695
            self._lock_count -= 1
 
696
        else:
 
697
            self._finish_transaction()
 
698
            self._lock.unlock()
 
699
            self._lock = None
 
700
            self._lock_mode = self._lock_count = None
 
701
 
1299
702
    def abspath(self, name):
1300
703
        """See Branch.abspath."""
1301
 
        return self.control_files._transport.abspath(name)
1302
 
 
1303
 
 
1304
 
    @deprecated_method(zero_sixteen)
 
704
        return self._transport.abspath(name)
 
705
 
 
706
    def _rel_controlfilename(self, file_or_path):
 
707
        if not isinstance(file_or_path, basestring):
 
708
            file_or_path = u'/'.join(file_or_path)
 
709
        if file_or_path == '':
 
710
            return bzrlib.BZRDIR
 
711
        return bzrlib.transport.urlescape(bzrlib.BZRDIR + u'/' + file_or_path)
 
712
 
 
713
    def controlfilename(self, file_or_path):
 
714
        """See Branch.controlfilename."""
 
715
        return self._transport.abspath(self._rel_controlfilename(file_or_path))
 
716
 
 
717
    def controlfile(self, file_or_path, mode='r'):
 
718
        """See Branch.controlfile."""
 
719
        import codecs
 
720
 
 
721
        relpath = self._rel_controlfilename(file_or_path)
 
722
        #TODO: codecs.open() buffers linewise, so it was overloaded with
 
723
        # a much larger buffer, do we need to do the same for getreader/getwriter?
 
724
        if mode == 'rb': 
 
725
            return self._transport.get(relpath)
 
726
        elif mode == 'wb':
 
727
            raise BzrError("Branch.controlfile(mode='wb') is not supported, use put_controlfiles")
 
728
        elif mode == 'r':
 
729
            # XXX: Do we really want errors='replace'?   Perhaps it should be
 
730
            # an error, or at least reported, if there's incorrectly-encoded
 
731
            # data inside a file.
 
732
            # <https://launchpad.net/products/bzr/+bug/3823>
 
733
            return codecs.getreader('utf-8')(self._transport.get(relpath), errors='replace')
 
734
        elif mode == 'w':
 
735
            raise BzrError("Branch.controlfile(mode='w') is not supported, use put_controlfiles")
 
736
        else:
 
737
            raise BzrError("invalid controlfile mode %r" % mode)
 
738
 
 
739
    def put_controlfile(self, path, f, encode=True):
 
740
        """See Branch.put_controlfile."""
 
741
        self.put_controlfiles([(path, f)], encode=encode)
 
742
 
 
743
    def put_controlfiles(self, files, encode=True):
 
744
        """See Branch.put_controlfiles."""
 
745
        import codecs
 
746
        ctrl_files = []
 
747
        for path, f in files:
 
748
            if encode:
 
749
                if isinstance(f, basestring):
 
750
                    f = f.encode('utf-8', 'replace')
 
751
                else:
 
752
                    f = codecs.getwriter('utf-8')(f, errors='replace')
 
753
            path = self._rel_controlfilename(path)
 
754
            ctrl_files.append((path, f))
 
755
        self._transport.put_multi(ctrl_files)
 
756
 
 
757
    def _make_control(self):
 
758
        from bzrlib.inventory import Inventory
 
759
        from bzrlib.weavefile import write_weave_v5
 
760
        from bzrlib.weave import Weave
 
761
        
 
762
        # Create an empty inventory
 
763
        sio = StringIO()
 
764
        # if we want per-tree root ids then this is the place to set
 
765
        # them; they're not needed for now and so ommitted for
 
766
        # simplicity.
 
767
        bzrlib.xml5.serializer_v5.write_inventory(Inventory(), sio)
 
768
        empty_inv = sio.getvalue()
 
769
        sio = StringIO()
 
770
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
 
771
        empty_weave = sio.getvalue()
 
772
 
 
773
        dirs = [[], 'revision-store', 'weaves']
 
774
        files = [('README', 
 
775
            "This is a Bazaar-NG control directory.\n"
 
776
            "Do not change any files in this directory.\n"),
 
777
            ('branch-format', BZR_BRANCH_FORMAT_6),
 
778
            ('revision-history', ''),
 
779
            ('branch-name', ''),
 
780
            ('branch-lock', ''),
 
781
            ('pending-merges', ''),
 
782
            ('inventory', empty_inv),
 
783
            ('inventory.weave', empty_weave),
 
784
            ('ancestry.weave', empty_weave)
 
785
        ]
 
786
        cfn = self._rel_controlfilename
 
787
        self._transport.mkdir_multi([cfn(d) for d in dirs])
 
788
        self.put_controlfiles(files)
 
789
        mutter('created control directory in ' + self._transport.base)
 
790
 
 
791
    def _check_format(self, relax_version_check):
 
792
        """Check this branch format is supported.
 
793
 
 
794
        The format level is stored, as an integer, in
 
795
        self._branch_format for code that needs to check it later.
 
796
 
 
797
        In the future, we might need different in-memory Branch
 
798
        classes to support downlevel branches.  But not yet.
 
799
        """
 
800
        try:
 
801
            fmt = self.controlfile('branch-format', 'r').read()
 
802
        except NoSuchFile:
 
803
            raise NotBranchError(path=self.base)
 
804
        mutter("got branch format %r", fmt)
 
805
        if fmt == BZR_BRANCH_FORMAT_6:
 
806
            self._branch_format = 6
 
807
        elif fmt == BZR_BRANCH_FORMAT_5:
 
808
            self._branch_format = 5
 
809
        elif fmt == BZR_BRANCH_FORMAT_4:
 
810
            self._branch_format = 4
 
811
 
 
812
        if (not relax_version_check
 
813
            and self._branch_format not in (5, 6)):
 
814
            raise errors.UnsupportedFormatError(
 
815
                           'sorry, branch format %r not supported' % fmt,
 
816
                           ['use a different bzr version',
 
817
                            'or remove the .bzr directory'
 
818
                            ' and "bzr init" again'])
 
819
 
1305
820
    @needs_read_lock
1306
821
    def get_root_id(self):
1307
822
        """See Branch.get_root_id."""
1308
 
        tree = self.repository.revision_tree(self.last_revision())
1309
 
        return tree.inventory.root.file_id
1310
 
 
1311
 
    def is_locked(self):
1312
 
        return self.control_files.is_locked()
1313
 
 
1314
 
    def lock_write(self, token=None):
1315
 
        repo_token = self.repository.lock_write()
1316
 
        try:
1317
 
            token = self.control_files.lock_write(token=token)
1318
 
        except:
1319
 
            self.repository.unlock()
1320
 
            raise
1321
 
        return token
1322
 
 
1323
 
    def lock_read(self):
1324
 
        self.repository.lock_read()
1325
 
        try:
1326
 
            self.control_files.lock_read()
1327
 
        except:
1328
 
            self.repository.unlock()
1329
 
            raise
1330
 
 
1331
 
    def unlock(self):
1332
 
        # TODO: test for failed two phase locks. This is known broken.
1333
 
        try:
1334
 
            self.control_files.unlock()
1335
 
        finally:
1336
 
            self.repository.unlock()
1337
 
        if not self.control_files.is_locked():
1338
 
            # we just released the lock
1339
 
            self._clear_cached_state()
1340
 
        
1341
 
    def peek_lock_mode(self):
1342
 
        if self.control_files._lock_count == 0:
1343
 
            return None
1344
 
        else:
1345
 
            return self.control_files._lock_mode
1346
 
 
1347
 
    def get_physical_lock_status(self):
1348
 
        return self.control_files.get_physical_lock_status()
 
823
        inv = self.get_inventory(self.last_revision())
 
824
        return inv.root.file_id
1349
825
 
1350
826
    @needs_read_lock
1351
 
    def print_file(self, file, revision_id):
 
827
    def print_file(self, file, revno):
1352
828
        """See Branch.print_file."""
1353
 
        return self.repository.print_file(file, revision_id)
 
829
        tree = self.revision_tree(self.get_rev_id(revno))
 
830
        # use inventory as it was in that revision
 
831
        file_id = tree.inventory.path2id(file)
 
832
        if not file_id:
 
833
            raise BzrError("%r is not present in revision %s" % (file, revno))
 
834
        tree.print_file(file_id)
1354
835
 
1355
836
    @needs_write_lock
1356
837
    def append_revision(self, *revision_ids):
1357
838
        """See Branch.append_revision."""
1358
 
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1359
839
        for revision_id in revision_ids:
1360
 
            _mod_revision.check_not_reserved_id(revision_id)
1361
840
            mutter("add {%s} to revision-history" % revision_id)
1362
841
        rev_history = self.revision_history()
1363
842
        rev_history.extend(revision_ids)
1364
843
        self.set_revision_history(rev_history)
1365
844
 
1366
 
    def _write_revision_history(self, history):
1367
 
        """Factored out of set_revision_history.
1368
 
 
1369
 
        This performs the actual writing to disk.
1370
 
        It is intended to be called by BzrBranch5.set_revision_history."""
1371
 
        self.control_files.put_bytes(
1372
 
            'revision-history', '\n'.join(history))
1373
 
 
1374
845
    @needs_write_lock
1375
846
    def set_revision_history(self, rev_history):
1376
847
        """See Branch.set_revision_history."""
1377
 
        rev_history = [osutils.safe_revision_id(r) for r in rev_history]
1378
 
        self._clear_cached_state()
1379
 
        self._write_revision_history(rev_history)
1380
 
        self._cache_revision_history(rev_history)
1381
 
        for hook in Branch.hooks['set_rh']:
1382
 
            hook(self, rev_history)
1383
 
 
1384
 
    @needs_write_lock
1385
 
    def set_last_revision_info(self, revno, revision_id):
1386
 
        revision_id = osutils.safe_revision_id(revision_id)
1387
 
        history = self._lefthand_history(revision_id)
1388
 
        assert len(history) == revno, '%d != %d' % (len(history), revno)
1389
 
        self.set_revision_history(history)
1390
 
 
1391
 
    def _gen_revision_history(self):
1392
 
        history = self.control_files.get('revision-history').read().split('\n')
1393
 
        if history[-1:] == ['']:
1394
 
            # There shouldn't be a trailing newline, but just in case.
1395
 
            history.pop()
1396
 
        return history
1397
 
 
1398
 
    def _lefthand_history(self, revision_id, last_rev=None,
1399
 
                          other_branch=None):
1400
 
        # stop_revision must be a descendant of last_revision
1401
 
        stop_graph = self.repository.get_revision_graph(revision_id)
1402
 
        if last_rev is not None and last_rev not in stop_graph:
1403
 
            # our previous tip is not merged into stop_revision
1404
 
            raise errors.DivergedBranches(self, other_branch)
1405
 
        # make a new revision history from the graph
1406
 
        current_rev_id = revision_id
1407
 
        new_history = []
1408
 
        while current_rev_id not in (None, _mod_revision.NULL_REVISION):
1409
 
            new_history.append(current_rev_id)
1410
 
            current_rev_id_parents = stop_graph[current_rev_id]
1411
 
            try:
1412
 
                current_rev_id = current_rev_id_parents[0]
1413
 
            except IndexError:
1414
 
                current_rev_id = None
1415
 
        new_history.reverse()
1416
 
        return new_history
1417
 
 
1418
 
    @needs_write_lock
1419
 
    def generate_revision_history(self, revision_id, last_rev=None,
1420
 
        other_branch=None):
1421
 
        """Create a new revision history that will finish with revision_id.
1422
 
 
1423
 
        :param revision_id: the new tip to use.
1424
 
        :param last_rev: The previous last_revision. If not None, then this
1425
 
            must be a ancestory of revision_id, or DivergedBranches is raised.
1426
 
        :param other_branch: The other branch that DivergedBranches should
1427
 
            raise with respect to.
1428
 
        """
1429
 
        revision_id = osutils.safe_revision_id(revision_id)
1430
 
        self.set_revision_history(self._lefthand_history(revision_id,
1431
 
            last_rev, other_branch))
1432
 
 
1433
 
    @needs_write_lock
 
848
        old_revision = self.last_revision()
 
849
        new_revision = rev_history[-1]
 
850
        self.put_controlfile('revision-history', '\n'.join(rev_history))
 
851
        self.working_tree().set_last_revision(new_revision, old_revision)
 
852
 
 
853
    def has_revision(self, revision_id):
 
854
        """See Branch.has_revision."""
 
855
        return (revision_id is None
 
856
                or self.revision_store.has_id(revision_id))
 
857
 
 
858
    @needs_read_lock
 
859
    def _get_revision_xml_file(self, revision_id):
 
860
        if not revision_id or not isinstance(revision_id, basestring):
 
861
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
 
862
        try:
 
863
            return self.revision_store.get(revision_id)
 
864
        except (IndexError, KeyError):
 
865
            raise bzrlib.errors.NoSuchRevision(self, revision_id)
 
866
 
 
867
    def get_revision_xml(self, revision_id):
 
868
        """See Branch.get_revision_xml."""
 
869
        return self._get_revision_xml_file(revision_id).read()
 
870
 
 
871
    def get_revision(self, revision_id):
 
872
        """See Branch.get_revision."""
 
873
        xml_file = self._get_revision_xml_file(revision_id)
 
874
 
 
875
        try:
 
876
            r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
 
877
        except SyntaxError, e:
 
878
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
 
879
                                         [revision_id,
 
880
                                          str(e)])
 
881
            
 
882
        assert r.revision_id == revision_id
 
883
        return r
 
884
 
 
885
    def get_revision_sha1(self, revision_id):
 
886
        """See Branch.get_revision_sha1."""
 
887
        # In the future, revision entries will be signed. At that
 
888
        # point, it is probably best *not* to include the signature
 
889
        # in the revision hash. Because that lets you re-sign
 
890
        # the revision, (add signatures/remove signatures) and still
 
891
        # have all hash pointers stay consistent.
 
892
        # But for now, just hash the contents.
 
893
        return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
 
894
 
 
895
    def get_ancestry(self, revision_id):
 
896
        """See Branch.get_ancestry."""
 
897
        if revision_id is None:
 
898
            return [None]
 
899
        w = self._get_inventory_weave()
 
900
        return [None] + map(w.idx_to_name,
 
901
                            w.inclusions([w.lookup(revision_id)]))
 
902
 
 
903
    def _get_inventory_weave(self):
 
904
        return self.control_weaves.get_weave('inventory',
 
905
                                             self.get_transaction())
 
906
 
 
907
    def get_inventory(self, revision_id):
 
908
        """See Branch.get_inventory."""
 
909
        xml = self.get_inventory_xml(revision_id)
 
910
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
911
 
 
912
    def get_inventory_xml(self, revision_id):
 
913
        """See Branch.get_inventory_xml."""
 
914
        try:
 
915
            assert isinstance(revision_id, basestring), type(revision_id)
 
916
            iw = self._get_inventory_weave()
 
917
            return iw.get_text(iw.lookup(revision_id))
 
918
        except IndexError:
 
919
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
 
920
 
 
921
    def get_inventory_sha1(self, revision_id):
 
922
        """See Branch.get_inventory_sha1."""
 
923
        return self.get_revision(revision_id).inventory_sha1
 
924
 
 
925
    def get_revision_inventory(self, revision_id):
 
926
        """See Branch.get_revision_inventory."""
 
927
        # TODO: Unify this with get_inventory()
 
928
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
929
        # must be the same as its revision, so this is trivial.
 
930
        if revision_id == None:
 
931
            # This does not make sense: if there is no revision,
 
932
            # then it is the current tree inventory surely ?!
 
933
            # and thus get_root_id() is something that looks at the last
 
934
            # commit on the branch, and the get_root_id is an inventory check.
 
935
            raise NotImplementedError
 
936
            # return Inventory(self.get_root_id())
 
937
        else:
 
938
            return self.get_inventory(revision_id)
 
939
 
 
940
    @needs_read_lock
 
941
    def revision_history(self):
 
942
        """See Branch.revision_history."""
 
943
        transaction = self.get_transaction()
 
944
        history = transaction.map.find_revision_history()
 
945
        if history is not None:
 
946
            mutter("cache hit for revision-history in %s", self)
 
947
            return list(history)
 
948
        history = [l.rstrip('\r\n') for l in
 
949
                self.controlfile('revision-history', 'r').readlines()]
 
950
        transaction.map.add_revision_history(history)
 
951
        # this call is disabled because revision_history is 
 
952
        # not really an object yet, and the transaction is for objects.
 
953
        # transaction.register_clean(history, precious=True)
 
954
        return list(history)
 
955
 
1434
956
    def update_revisions(self, other, stop_revision=None):
1435
957
        """See Branch.update_revisions."""
1436
 
        other.lock_read()
 
958
        from bzrlib.fetch import greedy_fetch
 
959
        if stop_revision is None:
 
960
            stop_revision = other.last_revision()
 
961
        ### Should this be checking is_ancestor instead of revision_history?
 
962
        if (stop_revision is not None and 
 
963
            stop_revision in self.revision_history()):
 
964
            return
 
965
        greedy_fetch(to_branch=self, from_branch=other,
 
966
                     revision=stop_revision)
 
967
        pullable_revs = self.pullable_revisions(other, stop_revision)
 
968
        if len(pullable_revs) > 0:
 
969
            self.append_revision(*pullable_revs)
 
970
 
 
971
    def pullable_revisions(self, other, stop_revision):
 
972
        """See Branch.pullable_revisions."""
 
973
        other_revno = other.revision_id_to_revno(stop_revision)
1437
974
        try:
1438
 
            if stop_revision is None:
1439
 
                stop_revision = other.last_revision()
1440
 
                if stop_revision is None:
1441
 
                    # if there are no commits, we're done.
1442
 
                    return
1443
 
            else:
1444
 
                stop_revision = osutils.safe_revision_id(stop_revision)
1445
 
            # whats the current last revision, before we fetch [and change it
1446
 
            # possibly]
1447
 
            last_rev = self.last_revision()
1448
 
            # we fetch here regardless of whether we need to so that we pickup
1449
 
            # filled in ghosts.
1450
 
            self.fetch(other, stop_revision)
1451
 
            my_ancestry = self.repository.get_ancestry(last_rev)
1452
 
            if stop_revision in my_ancestry:
1453
 
                # last_revision is a descendant of stop_revision
1454
 
                return
1455
 
            self.generate_revision_history(stop_revision, last_rev=last_rev,
1456
 
                other_branch=other)
1457
 
        finally:
1458
 
            other.unlock()
 
975
            return self.missing_revisions(other, other_revno)
 
976
        except DivergedBranches, e:
 
977
            try:
 
978
                pullable_revs = get_intervening_revisions(self.last_revision(),
 
979
                                                          stop_revision, self)
 
980
                assert self.last_revision() not in pullable_revs
 
981
                return pullable_revs
 
982
            except bzrlib.errors.NotAncestor:
 
983
                if is_ancestor(self.last_revision(), stop_revision, self):
 
984
                    return []
 
985
                else:
 
986
                    raise e
 
987
        
 
988
    def revision_tree(self, revision_id):
 
989
        """See Branch.revision_tree."""
 
990
        # TODO: refactor this to use an existing revision object
 
991
        # so we don't need to read it in twice.
 
992
        if revision_id == None or revision_id == NULL_REVISION:
 
993
            return EmptyTree()
 
994
        else:
 
995
            inv = self.get_revision_inventory(revision_id)
 
996
            return RevisionTree(self.weave_store, inv, revision_id)
1459
997
 
1460
998
    def basis_tree(self):
1461
999
        """See Branch.basis_tree."""
1462
 
        return self.repository.revision_tree(self.last_revision())
 
1000
        try:
 
1001
            revision_id = self.revision_history()[-1]
 
1002
            xml = self.working_tree().read_basis_inventory(revision_id)
 
1003
            inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
1004
            return RevisionTree(self.weave_store, inv, revision_id)
 
1005
        except (IndexError, NoSuchFile), e:
 
1006
            return self.revision_tree(self.last_revision())
1463
1007
 
1464
 
    @deprecated_method(zero_eight)
1465
1008
    def working_tree(self):
1466
 
        """Create a Working tree object for this branch."""
1467
 
 
1468
 
        from bzrlib.transport.local import LocalTransport
1469
 
        if (self.base.find('://') != -1 or 
1470
 
            not isinstance(self._transport, LocalTransport)):
 
1009
        """See Branch.working_tree."""
 
1010
        from bzrlib.workingtree import WorkingTree
 
1011
        if self._transport.base.find('://') != -1:
1471
1012
            raise NoWorkingTree(self.base)
1472
 
        return self.bzrdir.open_workingtree()
 
1013
        return WorkingTree(self.base, branch=self)
1473
1014
 
1474
1015
    @needs_write_lock
1475
 
    def pull(self, source, overwrite=False, stop_revision=None,
1476
 
             _hook_master=None, run_hooks=True):
1477
 
        """See Branch.pull.
1478
 
 
1479
 
        :param _hook_master: Private parameter - set the branch to 
1480
 
            be supplied as the master to push hooks.
1481
 
        :param run_hooks: Private parameter - if false, this branch
1482
 
            is being called because it's the master of the primary branch,
1483
 
            so it should not run its hooks.
1484
 
        """
1485
 
        result = PullResult()
1486
 
        result.source_branch = source
1487
 
        result.target_branch = self
 
1016
    def pull(self, source, overwrite=False):
 
1017
        """See Branch.pull."""
1488
1018
        source.lock_read()
1489
1019
        try:
1490
 
            result.old_revno, result.old_revid = self.last_revision_info()
 
1020
            old_count = len(self.revision_history())
1491
1021
            try:
1492
 
                self.update_revisions(source, stop_revision)
 
1022
                self.update_revisions(source)
1493
1023
            except DivergedBranches:
1494
1024
                if not overwrite:
1495
1025
                    raise
1496
 
            if overwrite:
1497
 
                if stop_revision is None:
1498
 
                    stop_revision = source.last_revision()
1499
 
                self.generate_revision_history(stop_revision)
1500
 
            result.tag_conflicts = source.tags.merge_to(self.tags)
1501
 
            result.new_revno, result.new_revid = self.last_revision_info()
1502
 
            if _hook_master:
1503
 
                result.master_branch = _hook_master
1504
 
                result.local_branch = self
1505
 
            else:
1506
 
                result.master_branch = self
1507
 
                result.local_branch = None
1508
 
            if run_hooks:
1509
 
                for hook in Branch.hooks['post_pull']:
1510
 
                    hook(result)
 
1026
                self.set_revision_history(source.revision_history())
 
1027
            new_count = len(self.revision_history())
 
1028
            return new_count - old_count
1511
1029
        finally:
1512
1030
            source.unlock()
1513
 
        return result
1514
1031
 
1515
 
    def _get_parent_location(self):
 
1032
    def get_parent(self):
 
1033
        """See Branch.get_parent."""
 
1034
        import errno
1516
1035
        _locs = ['parent', 'pull', 'x-pull']
1517
1036
        for l in _locs:
1518
1037
            try:
1519
 
                return self.control_files.get(l).read().strip('\n')
1520
 
            except NoSuchFile:
1521
 
                pass
 
1038
                return self.controlfile(l, 'r').read().strip('\n')
 
1039
            except IOError, e:
 
1040
                if e.errno != errno.ENOENT:
 
1041
                    raise
1522
1042
        return None
1523
1043
 
1524
 
    @needs_read_lock
1525
 
    def push(self, target, overwrite=False, stop_revision=None,
1526
 
             _override_hook_source_branch=None):
1527
 
        """See Branch.push.
1528
 
 
1529
 
        This is the basic concrete implementation of push()
1530
 
 
1531
 
        :param _override_hook_source_branch: If specified, run
1532
 
        the hooks passing this Branch as the source, rather than self.  
1533
 
        This is for use of RemoteBranch, where push is delegated to the
1534
 
        underlying vfs-based Branch. 
1535
 
        """
1536
 
        # TODO: Public option to disable running hooks - should be trivial but
1537
 
        # needs tests.
1538
 
        target.lock_write()
1539
 
        try:
1540
 
            result = self._push_with_bound_branches(target, overwrite,
1541
 
                    stop_revision,
1542
 
                    _override_hook_source_branch=_override_hook_source_branch)
1543
 
            return result
1544
 
        finally:
1545
 
            target.unlock()
1546
 
 
1547
 
    def _push_with_bound_branches(self, target, overwrite,
1548
 
            stop_revision,
1549
 
            _override_hook_source_branch=None):
1550
 
        """Push from self into target, and into target's master if any.
1551
 
        
1552
 
        This is on the base BzrBranch class even though it doesn't support 
1553
 
        bound branches because the *target* might be bound.
1554
 
        """
1555
 
        def _run_hooks():
1556
 
            if _override_hook_source_branch:
1557
 
                result.source_branch = _override_hook_source_branch
1558
 
            for hook in Branch.hooks['post_push']:
1559
 
                hook(result)
1560
 
 
1561
 
        bound_location = target.get_bound_location()
1562
 
        if bound_location and target.base != bound_location:
1563
 
            # there is a master branch.
1564
 
            #
1565
 
            # XXX: Why the second check?  Is it even supported for a branch to
1566
 
            # be bound to itself? -- mbp 20070507
1567
 
            master_branch = target.get_master_branch()
1568
 
            master_branch.lock_write()
1569
 
            try:
1570
 
                # push into the master from this branch.
1571
 
                self._basic_push(master_branch, overwrite, stop_revision)
1572
 
                # and push into the target branch from this. Note that we push from
1573
 
                # this branch again, because its considered the highest bandwidth
1574
 
                # repository.
1575
 
                result = self._basic_push(target, overwrite, stop_revision)
1576
 
                result.master_branch = master_branch
1577
 
                result.local_branch = target
1578
 
                _run_hooks()
1579
 
                return result
1580
 
            finally:
1581
 
                master_branch.unlock()
1582
 
        else:
1583
 
            # no master branch
1584
 
            result = self._basic_push(target, overwrite, stop_revision)
1585
 
            # TODO: Why set master_branch and local_branch if there's no
1586
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
1587
 
            # 20070504
1588
 
            result.master_branch = target
1589
 
            result.local_branch = None
1590
 
            _run_hooks()
1591
 
            return result
1592
 
 
1593
 
    def _basic_push(self, target, overwrite, stop_revision):
1594
 
        """Basic implementation of push without bound branches or hooks.
1595
 
 
1596
 
        Must be called with self read locked and target write locked.
1597
 
        """
1598
 
        result = PushResult()
1599
 
        result.source_branch = self
1600
 
        result.target_branch = target
1601
 
        result.old_revno, result.old_revid = target.last_revision_info()
1602
 
        try:
1603
 
            target.update_revisions(self, stop_revision)
1604
 
        except DivergedBranches:
1605
 
            if not overwrite:
1606
 
                raise
1607
 
        if overwrite:
1608
 
            target.set_revision_history(self.revision_history())
1609
 
        result.tag_conflicts = self.tags.merge_to(target.tags)
1610
 
        result.new_revno, result.new_revid = target.last_revision_info()
1611
 
        return result
1612
 
 
1613
 
    def get_parent(self):
1614
 
        """See Branch.get_parent."""
1615
 
 
1616
 
        assert self.base[-1] == '/'
1617
 
        parent = self._get_parent_location()
1618
 
        if parent is None:
1619
 
            return parent
1620
 
        # This is an old-format absolute path to a local branch
1621
 
        # turn it into a url
1622
 
        if parent.startswith('/'):
1623
 
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
1624
 
        try:
1625
 
            return urlutils.join(self.base[:-1], parent)
1626
 
        except errors.InvalidURLJoin, e:
1627
 
            raise errors.InaccessibleParent(parent, self.base)
 
1044
    def get_push_location(self):
 
1045
        """See Branch.get_push_location."""
 
1046
        config = bzrlib.config.BranchConfig(self)
 
1047
        push_loc = config.get_user_option('push_location')
 
1048
        return push_loc
1628
1049
 
1629
1050
    def set_push_location(self, location):
1630
1051
        """See Branch.set_push_location."""
1631
 
        self.get_config().set_user_option(
1632
 
            'push_location', location,
1633
 
            store=_mod_config.STORE_LOCATION_NORECURSE)
 
1052
        config = bzrlib.config.LocationConfig(self.base)
 
1053
        config.set_user_option('push_location', location)
1634
1054
 
1635
1055
    @needs_write_lock
1636
1056
    def set_parent(self, url):
1637
1057
        """See Branch.set_parent."""
1638
1058
        # TODO: Maybe delete old location files?
1639
 
        # URLs should never be unicode, even on the local fs,
1640
 
        # FIXUP this and get_parent in a future branch format bump:
1641
 
        # read and rewrite the file, and have the new format code read
1642
 
        # using .get not .get_utf8. RBC 20060125
1643
 
        if url is not None:
1644
 
            if isinstance(url, unicode):
1645
 
                try: 
1646
 
                    url = url.encode('ascii')
1647
 
                except UnicodeEncodeError:
1648
 
                    raise errors.InvalidURL(url,
1649
 
                        "Urls must be 7-bit ascii, "
1650
 
                        "use bzrlib.urlutils.escape")
1651
 
            url = urlutils.relative_url(self.base, url)
1652
 
        self._set_parent_location(url)
1653
 
 
1654
 
    def _set_parent_location(self, url):
1655
 
        if url is None:
1656
 
            self.control_files._transport.delete('parent')
1657
 
        else:
1658
 
            assert isinstance(url, str)
1659
 
            self.control_files.put_bytes('parent', url + '\n')
1660
 
 
1661
 
    @deprecated_function(zero_nine)
 
1059
        from bzrlib.atomicfile import AtomicFile
 
1060
        f = AtomicFile(self.controlfilename('parent'))
 
1061
        try:
 
1062
            f.write(url + '\n')
 
1063
            f.commit()
 
1064
        finally:
 
1065
            f.close()
 
1066
 
1662
1067
    def tree_config(self):
1663
 
        """DEPRECATED; call get_config instead.  
1664
 
        TreeConfig has become part of BranchConfig."""
1665
1068
        return TreeConfig(self)
1666
1069
 
1667
 
 
1668
 
class BzrBranch5(BzrBranch):
1669
 
    """A format 5 branch. This supports new features over plan branches.
1670
 
 
1671
 
    It has support for a master_branch which is the data for bound branches.
 
1070
    def sign_revision(self, revision_id, gpg_strategy):
 
1071
        """See Branch.sign_revision."""
 
1072
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
 
1073
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
 
1074
 
 
1075
    @needs_write_lock
 
1076
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
1077
        """See Branch.store_revision_signature."""
 
1078
        self.revision_store.add(StringIO(gpg_strategy.sign(plaintext)), 
 
1079
                                revision_id, "sig")
 
1080
 
 
1081
 
 
1082
class ScratchBranch(BzrBranch):
 
1083
    """Special test class: a branch that cleans up after itself.
 
1084
 
 
1085
    >>> b = ScratchBranch()
 
1086
    >>> isdir(b.base)
 
1087
    True
 
1088
    >>> bd = b.base
 
1089
    >>> b._transport.__del__()
 
1090
    >>> isdir(bd)
 
1091
    False
1672
1092
    """
1673
1093
 
1674
 
    def __init__(self,
1675
 
                 _format,
1676
 
                 _control_files,
1677
 
                 a_bzrdir,
1678
 
                 _repository):
1679
 
        super(BzrBranch5, self).__init__(_format=_format,
1680
 
                                         _control_files=_control_files,
1681
 
                                         a_bzrdir=a_bzrdir,
1682
 
                                         _repository=_repository)
1683
 
        
1684
 
    @needs_write_lock
1685
 
    def pull(self, source, overwrite=False, stop_revision=None,
1686
 
             run_hooks=True):
1687
 
        """Pull from source into self, updating my master if any.
1688
 
        
1689
 
        :param run_hooks: Private parameter - if false, this branch
1690
 
            is being called because it's the master of the primary branch,
1691
 
            so it should not run its hooks.
1692
 
        """
1693
 
        bound_location = self.get_bound_location()
1694
 
        master_branch = None
1695
 
        if bound_location and source.base != bound_location:
1696
 
            # not pulling from master, so we need to update master.
1697
 
            master_branch = self.get_master_branch()
1698
 
            master_branch.lock_write()
1699
 
        try:
1700
 
            if master_branch:
1701
 
                # pull from source into master.
1702
 
                master_branch.pull(source, overwrite, stop_revision,
1703
 
                    run_hooks=False)
1704
 
            return super(BzrBranch5, self).pull(source, overwrite,
1705
 
                stop_revision, _hook_master=master_branch,
1706
 
                run_hooks=run_hooks)
1707
 
        finally:
1708
 
            if master_branch:
1709
 
                master_branch.unlock()
1710
 
 
1711
 
    def get_bound_location(self):
1712
 
        try:
1713
 
            return self.control_files.get_utf8('bound').read()[:-1]
1714
 
        except errors.NoSuchFile:
1715
 
            return None
1716
 
 
1717
 
    @needs_read_lock
1718
 
    def get_master_branch(self):
1719
 
        """Return the branch we are bound to.
1720
 
        
1721
 
        :return: Either a Branch, or None
1722
 
 
1723
 
        This could memoise the branch, but if thats done
1724
 
        it must be revalidated on each new lock.
1725
 
        So for now we just don't memoise it.
1726
 
        # RBC 20060304 review this decision.
1727
 
        """
1728
 
        bound_loc = self.get_bound_location()
1729
 
        if not bound_loc:
1730
 
            return None
1731
 
        try:
1732
 
            return Branch.open(bound_loc)
1733
 
        except (errors.NotBranchError, errors.ConnectionError), e:
1734
 
            raise errors.BoundBranchConnectionFailure(
1735
 
                    self, bound_loc, e)
1736
 
 
1737
 
    @needs_write_lock
1738
 
    def set_bound_location(self, location):
1739
 
        """Set the target where this branch is bound to.
1740
 
 
1741
 
        :param location: URL to the target branch
1742
 
        """
1743
 
        if location:
1744
 
            self.control_files.put_utf8('bound', location+'\n')
 
1094
    def __init__(self, files=[], dirs=[], transport=None):
 
1095
        """Make a test branch.
 
1096
 
 
1097
        This creates a temporary directory and runs init-tree in it.
 
1098
 
 
1099
        If any files are listed, they are created in the working copy.
 
1100
        """
 
1101
        if transport is None:
 
1102
            transport = bzrlib.transport.local.ScratchTransport()
 
1103
            super(ScratchBranch, self).__init__(transport, init=True)
1745
1104
        else:
1746
 
            try:
1747
 
                self.control_files._transport.delete('bound')
1748
 
            except NoSuchFile:
1749
 
                return False
 
1105
            super(ScratchBranch, self).__init__(transport)
 
1106
 
 
1107
        for d in dirs:
 
1108
            self._transport.mkdir(d)
 
1109
            
 
1110
        for f in files:
 
1111
            self._transport.put(f, 'content of %s' % f)
 
1112
 
 
1113
 
 
1114
    def clone(self):
 
1115
        """
 
1116
        >>> orig = ScratchBranch(files=["file1", "file2"])
 
1117
        >>> clone = orig.clone()
 
1118
        >>> if os.name != 'nt':
 
1119
        ...   os.path.samefile(orig.base, clone.base)
 
1120
        ... else:
 
1121
        ...   orig.base == clone.base
 
1122
        ...
 
1123
        False
 
1124
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
 
1125
        True
 
1126
        """
 
1127
        from shutil import copytree
 
1128
        from tempfile import mkdtemp
 
1129
        base = mkdtemp()
 
1130
        os.rmdir(base)
 
1131
        copytree(self.base, base, symlinks=True)
 
1132
        return ScratchBranch(
 
1133
            transport=bzrlib.transport.local.ScratchTransport(base))
 
1134
    
 
1135
 
 
1136
######################################################################
 
1137
# predicates
 
1138
 
 
1139
 
 
1140
def is_control_file(filename):
 
1141
    ## FIXME: better check
 
1142
    filename = os.path.normpath(filename)
 
1143
    while filename != '':
 
1144
        head, tail = os.path.split(filename)
 
1145
        ## mutter('check %r for control file' % ((head, tail), ))
 
1146
        if tail == bzrlib.BZRDIR:
1750
1147
            return True
1751
 
 
1752
 
    @needs_write_lock
1753
 
    def bind(self, other):
1754
 
        """Bind this branch to the branch other.
1755
 
 
1756
 
        This does not push or pull data between the branches, though it does
1757
 
        check for divergence to raise an error when the branches are not
1758
 
        either the same, or one a prefix of the other. That behaviour may not
1759
 
        be useful, so that check may be removed in future.
1760
 
        
1761
 
        :param other: The branch to bind to
1762
 
        :type other: Branch
1763
 
        """
1764
 
        # TODO: jam 20051230 Consider checking if the target is bound
1765
 
        #       It is debatable whether you should be able to bind to
1766
 
        #       a branch which is itself bound.
1767
 
        #       Committing is obviously forbidden,
1768
 
        #       but binding itself may not be.
1769
 
        #       Since we *have* to check at commit time, we don't
1770
 
        #       *need* to check here
1771
 
 
1772
 
        # we want to raise diverged if:
1773
 
        # last_rev is not in the other_last_rev history, AND
1774
 
        # other_last_rev is not in our history, and do it without pulling
1775
 
        # history around
1776
 
        last_rev = self.last_revision()
1777
 
        if last_rev is not None:
1778
 
            other.lock_read()
1779
 
            try:
1780
 
                other_last_rev = other.last_revision()
1781
 
                if other_last_rev is not None:
1782
 
                    # neither branch is new, we have to do some work to
1783
 
                    # ascertain diversion.
1784
 
                    remote_graph = other.repository.get_revision_graph(
1785
 
                        other_last_rev)
1786
 
                    local_graph = self.repository.get_revision_graph(last_rev)
1787
 
                    if (last_rev not in remote_graph and
1788
 
                        other_last_rev not in local_graph):
1789
 
                        raise errors.DivergedBranches(self, other)
1790
 
            finally:
1791
 
                other.unlock()
1792
 
        self.set_bound_location(other.base)
1793
 
 
1794
 
    @needs_write_lock
1795
 
    def unbind(self):
1796
 
        """If bound, unbind"""
1797
 
        return self.set_bound_location(None)
1798
 
 
1799
 
    @needs_write_lock
1800
 
    def update(self):
1801
 
        """Synchronise this branch with the master branch if any. 
1802
 
 
1803
 
        :return: None or the last_revision that was pivoted out during the
1804
 
                 update.
1805
 
        """
1806
 
        master = self.get_master_branch()
1807
 
        if master is not None:
1808
 
            old_tip = self.last_revision()
1809
 
            self.pull(master, overwrite=True)
1810
 
            if old_tip in self.repository.get_ancestry(self.last_revision()):
1811
 
                return None
1812
 
            return old_tip
1813
 
        return None
1814
 
 
1815
 
 
1816
 
class BzrBranchExperimental(BzrBranch5):
1817
 
    """Bzr experimental branch format
1818
 
 
1819
 
    This format has:
1820
 
     - a revision-history file.
1821
 
     - a format string
1822
 
     - a lock dir guarding the branch itself
1823
 
     - all of this stored in a branch/ subdirectory
1824
 
     - works with shared repositories.
1825
 
     - a tag dictionary in the branch
1826
 
 
1827
 
    This format is new in bzr 0.15, but shouldn't be used for real data, 
1828
 
    only for testing.
1829
 
 
1830
 
    This class acts as it's own BranchFormat.
1831
 
    """
1832
 
 
1833
 
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1834
 
 
1835
 
    @classmethod
1836
 
    def get_format_string(cls):
1837
 
        """See BranchFormat.get_format_string()."""
1838
 
        return "Bazaar-NG branch format experimental\n"
1839
 
 
1840
 
    @classmethod
1841
 
    def get_format_description(cls):
1842
 
        """See BranchFormat.get_format_description()."""
1843
 
        return "Experimental branch format"
1844
 
 
1845
 
    @classmethod
1846
 
    def get_reference(cls, a_bzrdir):
1847
 
        """Get the target reference of the branch in a_bzrdir.
1848
 
 
1849
 
        format probing must have been completed before calling
1850
 
        this method - it is assumed that the format of the branch
1851
 
        in a_bzrdir is correct.
1852
 
 
1853
 
        :param a_bzrdir: The bzrdir to get the branch data from.
1854
 
        :return: None if the branch is not a reference branch.
1855
 
        """
1856
 
        return None
1857
 
 
1858
 
    @classmethod
1859
 
    def _initialize_control_files(cls, a_bzrdir, utf8_files, lock_filename,
1860
 
            lock_class):
1861
 
        branch_transport = a_bzrdir.get_branch_transport(cls)
1862
 
        control_files = lockable_files.LockableFiles(branch_transport,
1863
 
            lock_filename, lock_class)
1864
 
        control_files.create_lock()
1865
 
        control_files.lock_write()
1866
 
        try:
1867
 
            for filename, content in utf8_files:
1868
 
                control_files.put_utf8(filename, content)
1869
 
        finally:
1870
 
            control_files.unlock()
1871
 
        
1872
 
    @classmethod
1873
 
    def initialize(cls, a_bzrdir):
1874
 
        """Create a branch of this format in a_bzrdir."""
1875
 
        utf8_files = [('format', cls.get_format_string()),
1876
 
                      ('revision-history', ''),
1877
 
                      ('branch-name', ''),
1878
 
                      ('tags', ''),
1879
 
                      ]
1880
 
        cls._initialize_control_files(a_bzrdir, utf8_files,
1881
 
            'lock', lockdir.LockDir)
1882
 
        return cls.open(a_bzrdir, _found=True)
1883
 
 
1884
 
    @classmethod
1885
 
    def open(cls, a_bzrdir, _found=False):
1886
 
        """Return the branch object for a_bzrdir
1887
 
 
1888
 
        _found is a private parameter, do not use it. It is used to indicate
1889
 
               if format probing has already be done.
1890
 
        """
1891
 
        if not _found:
1892
 
            format = BranchFormat.find_format(a_bzrdir)
1893
 
            assert format.__class__ == cls
1894
 
        transport = a_bzrdir.get_branch_transport(None)
1895
 
        control_files = lockable_files.LockableFiles(transport, 'lock',
1896
 
                                                     lockdir.LockDir)
1897
 
        return cls(_format=cls,
1898
 
            _control_files=control_files,
1899
 
            a_bzrdir=a_bzrdir,
1900
 
            _repository=a_bzrdir.find_repository())
1901
 
 
1902
 
    @classmethod
1903
 
    def is_supported(cls):
1904
 
        return True
1905
 
 
1906
 
    def _make_tags(self):
1907
 
        return BasicTags(self)
1908
 
 
1909
 
    @classmethod
1910
 
    def supports_tags(cls):
1911
 
        return True
1912
 
 
1913
 
 
1914
 
BranchFormat.register_format(BzrBranchExperimental)
1915
 
 
1916
 
 
1917
 
class BzrBranch6(BzrBranch5):
1918
 
 
1919
 
    @needs_read_lock
1920
 
    def last_revision_info(self):
1921
 
        revision_string = self.control_files.get('last-revision').read()
1922
 
        revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
1923
 
        revision_id = cache_utf8.get_cached_utf8(revision_id)
1924
 
        revno = int(revno)
1925
 
        return revno, revision_id
1926
 
 
1927
 
    def last_revision(self):
1928
 
        """Return last revision id, or None"""
1929
 
        revision_id = self.last_revision_info()[1]
1930
 
        if revision_id == _mod_revision.NULL_REVISION:
1931
 
            revision_id = None
1932
 
        return revision_id
1933
 
 
1934
 
    def _write_last_revision_info(self, revno, revision_id):
1935
 
        """Simply write out the revision id, with no checks.
1936
 
 
1937
 
        Use set_last_revision_info to perform this safely.
1938
 
 
1939
 
        Does not update the revision_history cache.
1940
 
        Intended to be called by set_last_revision_info and
1941
 
        _write_revision_history.
1942
 
        """
1943
 
        if revision_id is None:
1944
 
            revision_id = 'null:'
1945
 
        out_string = '%d %s\n' % (revno, revision_id)
1946
 
        self.control_files.put_bytes('last-revision', out_string)
1947
 
 
1948
 
    @needs_write_lock
1949
 
    def set_last_revision_info(self, revno, revision_id):
1950
 
        revision_id = osutils.safe_revision_id(revision_id)
1951
 
        if self._get_append_revisions_only():
1952
 
            self._check_history_violation(revision_id)
1953
 
        self._write_last_revision_info(revno, revision_id)
1954
 
        self._clear_cached_state()
1955
 
 
1956
 
    def _check_history_violation(self, revision_id):
1957
 
        last_revision = self.last_revision()
1958
 
        if last_revision is None:
1959
 
            return
1960
 
        if last_revision not in self._lefthand_history(revision_id):
1961
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
1962
 
 
1963
 
    def _gen_revision_history(self):
1964
 
        """Generate the revision history from last revision
1965
 
        """
1966
 
        history = list(self.repository.iter_reverse_revision_history(
1967
 
            self.last_revision()))
1968
 
        history.reverse()
1969
 
        return history
1970
 
 
1971
 
    def _write_revision_history(self, history):
1972
 
        """Factored out of set_revision_history.
1973
 
 
1974
 
        This performs the actual writing to disk, with format-specific checks.
1975
 
        It is intended to be called by BzrBranch5.set_revision_history.
1976
 
        """
1977
 
        if len(history) == 0:
1978
 
            last_revision = 'null:'
1979
 
        else:
1980
 
            if history != self._lefthand_history(history[-1]):
1981
 
                raise errors.NotLefthandHistory(history)
1982
 
            last_revision = history[-1]
1983
 
        if self._get_append_revisions_only():
1984
 
            self._check_history_violation(last_revision)
1985
 
        self._write_last_revision_info(len(history), last_revision)
1986
 
 
1987
 
    @needs_write_lock
1988
 
    def append_revision(self, *revision_ids):
1989
 
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1990
 
        if len(revision_ids) == 0:
1991
 
            return
1992
 
        prev_revno, prev_revision = self.last_revision_info()
1993
 
        for revision in self.repository.get_revisions(revision_ids):
1994
 
            if prev_revision == _mod_revision.NULL_REVISION:
1995
 
                if revision.parent_ids != []:
1996
 
                    raise errors.NotLeftParentDescendant(self, prev_revision,
1997
 
                                                         revision.revision_id)
1998
 
            else:
1999
 
                if revision.parent_ids[0] != prev_revision:
2000
 
                    raise errors.NotLeftParentDescendant(self, prev_revision,
2001
 
                                                         revision.revision_id)
2002
 
            prev_revision = revision.revision_id
2003
 
        self.set_last_revision_info(prev_revno + len(revision_ids),
2004
 
                                    revision_ids[-1])
2005
 
 
2006
 
    @needs_write_lock
2007
 
    def _set_parent_location(self, url):
2008
 
        """Set the parent branch"""
2009
 
        self._set_config_location('parent_location', url, make_relative=True)
2010
 
 
2011
 
    @needs_read_lock
2012
 
    def _get_parent_location(self):
2013
 
        """Set the parent branch"""
2014
 
        return self._get_config_location('parent_location')
2015
 
 
2016
 
    def set_push_location(self, location):
2017
 
        """See Branch.set_push_location."""
2018
 
        self._set_config_location('push_location', location)
2019
 
 
2020
 
    def set_bound_location(self, location):
2021
 
        """See Branch.set_push_location."""
2022
 
        result = None
2023
 
        config = self.get_config()
2024
 
        if location is None:
2025
 
            if config.get_user_option('bound') != 'True':
2026
 
                return False
2027
 
            else:
2028
 
                config.set_user_option('bound', 'False')
2029
 
                return True
2030
 
        else:
2031
 
            self._set_config_location('bound_location', location,
2032
 
                                      config=config)
2033
 
            config.set_user_option('bound', 'True')
2034
 
        return True
2035
 
 
2036
 
    def _get_bound_location(self, bound):
2037
 
        """Return the bound location in the config file.
2038
 
 
2039
 
        Return None if the bound parameter does not match"""
2040
 
        config = self.get_config()
2041
 
        config_bound = (config.get_user_option('bound') == 'True')
2042
 
        if config_bound != bound:
2043
 
            return None
2044
 
        return self._get_config_location('bound_location', config=config)
2045
 
 
2046
 
    def get_bound_location(self):
2047
 
        """See Branch.set_push_location."""
2048
 
        return self._get_bound_location(True)
2049
 
 
2050
 
    def get_old_bound_location(self):
2051
 
        """See Branch.get_old_bound_location"""
2052
 
        return self._get_bound_location(False)
2053
 
 
2054
 
    def set_append_revisions_only(self, enabled):
2055
 
        if enabled:
2056
 
            value = 'True'
2057
 
        else:
2058
 
            value = 'False'
2059
 
        self.get_config().set_user_option('append_revisions_only', value)
2060
 
 
2061
 
    def _get_append_revisions_only(self):
2062
 
        value = self.get_config().get_user_option('append_revisions_only')
2063
 
        return value == 'True'
2064
 
 
2065
 
    def _synchronize_history(self, destination, revision_id):
2066
 
        """Synchronize last revision and revision history between branches.
2067
 
 
2068
 
        This version is most efficient when the destination is also a
2069
 
        BzrBranch6, but works for BzrBranch5, as long as the destination's
2070
 
        repository contains all the lefthand ancestors of the intended
2071
 
        last_revision.  If not, set_last_revision_info will fail.
2072
 
 
2073
 
        :param destination: The branch to copy the history into
2074
 
        :param revision_id: The revision-id to truncate history at.  May
2075
 
          be None to copy complete history.
2076
 
        """
2077
 
        if revision_id is None:
2078
 
            revno, revision_id = self.last_revision_info()
2079
 
        else:
2080
 
            revno = self.revision_id_to_revno(revision_id)
2081
 
        destination.set_last_revision_info(revno, revision_id)
2082
 
 
2083
 
    def _make_tags(self):
2084
 
        return BasicTags(self)
2085
 
 
2086
 
 
2087
 
class BranchTestProviderAdapter(object):
2088
 
    """A tool to generate a suite testing multiple branch formats at once.
2089
 
 
2090
 
    This is done by copying the test once for each transport and injecting
2091
 
    the transport_server, transport_readonly_server, and branch_format
2092
 
    classes into each copy. Each copy is also given a new id() to make it
2093
 
    easy to identify.
2094
 
    """
2095
 
 
2096
 
    def __init__(self, transport_server, transport_readonly_server, formats,
2097
 
        vfs_transport_factory=None):
2098
 
        self._transport_server = transport_server
2099
 
        self._transport_readonly_server = transport_readonly_server
2100
 
        self._formats = formats
2101
 
    
2102
 
    def adapt(self, test):
2103
 
        result = TestSuite()
2104
 
        for branch_format, bzrdir_format in self._formats:
2105
 
            new_test = deepcopy(test)
2106
 
            new_test.transport_server = self._transport_server
2107
 
            new_test.transport_readonly_server = self._transport_readonly_server
2108
 
            new_test.bzrdir_format = bzrdir_format
2109
 
            new_test.branch_format = branch_format
2110
 
            def make_new_test_id():
2111
 
                # the format can be either a class or an instance
2112
 
                name = getattr(branch_format, '__name__',
2113
 
                        branch_format.__class__.__name__)
2114
 
                new_id = "%s(%s)" % (new_test.id(), name)
2115
 
                return lambda: new_id
2116
 
            new_test.id = make_new_test_id()
2117
 
            result.addTest(new_test)
2118
 
        return result
2119
 
 
2120
 
 
2121
 
######################################################################
2122
 
# results of operations
2123
 
 
2124
 
 
2125
 
class _Result(object):
2126
 
 
2127
 
    def _show_tag_conficts(self, to_file):
2128
 
        if not getattr(self, 'tag_conflicts', None):
2129
 
            return
2130
 
        to_file.write('Conflicting tags:\n')
2131
 
        for name, value1, value2 in self.tag_conflicts:
2132
 
            to_file.write('    %s\n' % (name, ))
2133
 
 
2134
 
 
2135
 
class PullResult(_Result):
2136
 
    """Result of a Branch.pull operation.
2137
 
 
2138
 
    :ivar old_revno: Revision number before pull.
2139
 
    :ivar new_revno: Revision number after pull.
2140
 
    :ivar old_revid: Tip revision id before pull.
2141
 
    :ivar new_revid: Tip revision id after pull.
2142
 
    :ivar source_branch: Source (local) branch object.
2143
 
    :ivar master_branch: Master branch of the target, or None.
2144
 
    :ivar target_branch: Target/destination branch object.
2145
 
    """
2146
 
 
2147
 
    def __int__(self):
2148
 
        # DEPRECATED: pull used to return the change in revno
2149
 
        return self.new_revno - self.old_revno
2150
 
 
2151
 
    def report(self, to_file):
2152
 
        if self.old_revid == self.new_revid:
2153
 
            to_file.write('No revisions to pull.\n')
2154
 
        else:
2155
 
            to_file.write('Now on revision %d.\n' % self.new_revno)
2156
 
        self._show_tag_conficts(to_file)
2157
 
 
2158
 
 
2159
 
class PushResult(_Result):
2160
 
    """Result of a Branch.push operation.
2161
 
 
2162
 
    :ivar old_revno: Revision number before push.
2163
 
    :ivar new_revno: Revision number after push.
2164
 
    :ivar old_revid: Tip revision id before push.
2165
 
    :ivar new_revid: Tip revision id after push.
2166
 
    :ivar source_branch: Source branch object.
2167
 
    :ivar master_branch: Master branch of the target, or None.
2168
 
    :ivar target_branch: Target/destination branch object.
2169
 
    """
2170
 
 
2171
 
    def __int__(self):
2172
 
        # DEPRECATED: push used to return the change in revno
2173
 
        return self.new_revno - self.old_revno
2174
 
 
2175
 
    def report(self, to_file):
2176
 
        """Write a human-readable description of the result."""
2177
 
        if self.old_revid == self.new_revid:
2178
 
            to_file.write('No new revisions to push.\n')
2179
 
        else:
2180
 
            to_file.write('Pushed up to revision %d.\n' % self.new_revno)
2181
 
        self._show_tag_conficts(to_file)
2182
 
 
2183
 
 
2184
 
class BranchCheckResult(object):
2185
 
    """Results of checking branch consistency.
2186
 
 
2187
 
    :see: Branch.check
2188
 
    """
2189
 
 
2190
 
    def __init__(self, branch):
2191
 
        self.branch = branch
2192
 
 
2193
 
    def report_results(self, verbose):
2194
 
        """Report the check results via trace.note.
2195
 
        
2196
 
        :param verbose: Requests more detailed display of what was checked,
2197
 
            if any.
2198
 
        """
2199
 
        note('checked branch %s format %s',
2200
 
             self.branch.base,
2201
 
             self.branch._format)
2202
 
 
2203
 
 
2204
 
class Converter5to6(object):
2205
 
    """Perform an in-place upgrade of format 5 to format 6"""
2206
 
 
2207
 
    def convert(self, branch):
2208
 
        # Data for 5 and 6 can peacefully coexist.
2209
 
        format = BzrBranchFormat6()
2210
 
        new_branch = format.open(branch.bzrdir, _found=True)
2211
 
 
2212
 
        # Copy source data into target
2213
 
        new_branch.set_last_revision_info(*branch.last_revision_info())
2214
 
        new_branch.set_parent(branch.get_parent())
2215
 
        new_branch.set_bound_location(branch.get_bound_location())
2216
 
        new_branch.set_push_location(branch.get_push_location())
2217
 
 
2218
 
        # New branch has no tags by default
2219
 
        new_branch.tags._set_tag_dict({})
2220
 
 
2221
 
        # Copying done; now update target format
2222
 
        new_branch.control_files.put_utf8('format',
2223
 
            format.get_format_string())
2224
 
 
2225
 
        # Clean up old files
2226
 
        new_branch.control_files._transport.delete('revision-history')
2227
 
        try:
2228
 
            branch.set_parent(None)
2229
 
        except NoSuchFile:
2230
 
            pass
2231
 
        branch.set_bound_location(None)
 
1148
        if filename == head:
 
1149
            break
 
1150
        filename = head
 
1151
    return False