~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: Jelmer Vernooij
  • Date: 2011-02-24 12:17:19 UTC
  • mto: (5676.1.5 per_interrepo-extra)
  • mto: This revision was merged to the branch mainline in revision 5686.
  • Revision ID: jelmer@samba.org-20110224121719-nvhwz19krifo3xov
Consistent naming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2007-2011 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""WorkingTree4 format and implementation.
 
18
 
 
19
WorkingTree4 provides the dirstate based working tree logic.
 
20
 
 
21
To get a WorkingTree, call bzrdir.open_workingtree() or
 
22
WorkingTree.open(dir).
 
23
"""
 
24
 
 
25
from cStringIO import StringIO
 
26
import os
 
27
import sys
 
28
 
 
29
from bzrlib.lazy_import import lazy_import
 
30
lazy_import(globals(), """
 
31
import errno
 
32
import stat
 
33
 
 
34
import bzrlib
 
35
from bzrlib import (
 
36
    bzrdir,
 
37
    cache_utf8,
 
38
    debug,
 
39
    dirstate,
 
40
    errors,
 
41
    generate_ids,
 
42
    osutils,
 
43
    revision as _mod_revision,
 
44
    revisiontree,
 
45
    trace,
 
46
    transform,
 
47
    views,
 
48
    )
 
49
import bzrlib.branch
 
50
import bzrlib.ui
 
51
""")
 
52
 
 
53
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
54
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
 
55
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
 
56
from bzrlib.lock import LogicalLockResult
 
57
from bzrlib.mutabletree import needs_tree_write_lock
 
58
from bzrlib.osutils import (
 
59
    file_kind,
 
60
    isdir,
 
61
    pathjoin,
 
62
    realpath,
 
63
    safe_unicode,
 
64
    )
 
65
from bzrlib.trace import mutter
 
66
from bzrlib.transport.local import LocalTransport
 
67
from bzrlib.tree import InterTree
 
68
from bzrlib.tree import Tree
 
69
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
 
70
 
 
71
 
 
72
class DirStateWorkingTree(WorkingTree3):
 
73
    def __init__(self, basedir,
 
74
                 branch,
 
75
                 _control_files=None,
 
76
                 _format=None,
 
77
                 _bzrdir=None):
 
78
        """Construct a WorkingTree for basedir.
 
79
 
 
80
        If the branch is not supplied, it is opened automatically.
 
81
        If the branch is supplied, it must be the branch for this basedir.
 
82
        (branch.base is not cross checked, because for remote branches that
 
83
        would be meaningless).
 
84
        """
 
85
        self._format = _format
 
86
        self.bzrdir = _bzrdir
 
87
        basedir = safe_unicode(basedir)
 
88
        mutter("opening working tree %r", basedir)
 
89
        self._branch = branch
 
90
        self.basedir = realpath(basedir)
 
91
        # if branch is at our basedir and is a format 6 or less
 
92
        # assume all other formats have their own control files.
 
93
        self._control_files = _control_files
 
94
        self._transport = self._control_files._transport
 
95
        self._dirty = None
 
96
        #-------------
 
97
        # during a read or write lock these objects are set, and are
 
98
        # None the rest of the time.
 
99
        self._dirstate = None
 
100
        self._inventory = None
 
101
        #-------------
 
102
        self._setup_directory_is_tree_reference()
 
103
        self._detect_case_handling()
 
104
        self._rules_searcher = None
 
105
        self.views = self._make_views()
 
106
        #--- allow tests to select the dirstate iter_changes implementation
 
107
        self._iter_changes = dirstate._process_entry
 
108
 
 
109
    @needs_tree_write_lock
 
110
    def _add(self, files, ids, kinds):
 
111
        """See MutableTree._add."""
 
112
        state = self.current_dirstate()
 
113
        for f, file_id, kind in zip(files, ids, kinds):
 
114
            f = f.strip('/')
 
115
            if self.path2id(f):
 
116
                # special case tree root handling.
 
117
                if f == '' and self.path2id(f) == ROOT_ID:
 
118
                    state.set_path_id('', generate_ids.gen_file_id(f))
 
119
                continue
 
120
            if file_id is None:
 
121
                file_id = generate_ids.gen_file_id(f)
 
122
            # deliberately add the file with no cached stat or sha1
 
123
            # - on the first access it will be gathered, and we can
 
124
            # always change this once tests are all passing.
 
125
            state.add(f, file_id, kind, None, '')
 
126
        self._make_dirty(reset_inventory=True)
 
127
 
 
128
    def _make_dirty(self, reset_inventory):
 
129
        """Make the tree state dirty.
 
130
 
 
131
        :param reset_inventory: True if the cached inventory should be removed
 
132
            (presuming there is one).
 
133
        """
 
134
        self._dirty = True
 
135
        if reset_inventory and self._inventory is not None:
 
136
            self._inventory = None
 
137
 
 
138
    @needs_tree_write_lock
 
139
    def add_reference(self, sub_tree):
 
140
        # use standard implementation, which calls back to self._add
 
141
        #
 
142
        # So we don't store the reference_revision in the working dirstate,
 
143
        # it's just recorded at the moment of commit.
 
144
        self._add_reference(sub_tree)
 
145
 
 
146
    def break_lock(self):
 
147
        """Break a lock if one is present from another instance.
 
148
 
 
149
        Uses the ui factory to ask for confirmation if the lock may be from
 
150
        an active process.
 
151
 
 
152
        This will probe the repository for its lock as well.
 
153
        """
 
154
        # if the dirstate is locked by an active process, reject the break lock
 
155
        # call.
 
156
        try:
 
157
            if self._dirstate is None:
 
158
                clear = True
 
159
            else:
 
160
                clear = False
 
161
            state = self._current_dirstate()
 
162
            if state._lock_token is not None:
 
163
                # we already have it locked. sheese, cant break our own lock.
 
164
                raise errors.LockActive(self.basedir)
 
165
            else:
 
166
                try:
 
167
                    # try for a write lock - need permission to get one anyhow
 
168
                    # to break locks.
 
169
                    state.lock_write()
 
170
                except errors.LockContention:
 
171
                    # oslocks fail when a process is still live: fail.
 
172
                    # TODO: get the locked lockdir info and give to the user to
 
173
                    # assist in debugging.
 
174
                    raise errors.LockActive(self.basedir)
 
175
                else:
 
176
                    state.unlock()
 
177
        finally:
 
178
            if clear:
 
179
                self._dirstate = None
 
180
        self._control_files.break_lock()
 
181
        self.branch.break_lock()
 
182
 
 
183
    def _comparison_data(self, entry, path):
 
184
        kind, executable, stat_value = \
 
185
            WorkingTree3._comparison_data(self, entry, path)
 
186
        # it looks like a plain directory, but it's really a reference -- see
 
187
        # also kind()
 
188
        if (self._repo_supports_tree_reference and kind == 'directory'
 
189
            and entry is not None and entry.kind == 'tree-reference'):
 
190
            kind = 'tree-reference'
 
191
        return kind, executable, stat_value
 
192
 
 
193
    @needs_write_lock
 
194
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
195
        # mark the tree as dirty post commit - commit
 
196
        # can change the current versioned list by doing deletes.
 
197
        result = WorkingTree3.commit(self, message, revprops, *args, **kwargs)
 
198
        self._make_dirty(reset_inventory=True)
 
199
        return result
 
200
 
 
201
    def current_dirstate(self):
 
202
        """Return the current dirstate object.
 
203
 
 
204
        This is not part of the tree interface and only exposed for ease of
 
205
        testing.
 
206
 
 
207
        :raises errors.NotWriteLocked: when not in a lock.
 
208
        """
 
209
        self._must_be_locked()
 
210
        return self._current_dirstate()
 
211
 
 
212
    def _current_dirstate(self):
 
213
        """Internal function that does not check lock status.
 
214
 
 
215
        This is needed for break_lock which also needs the dirstate.
 
216
        """
 
217
        if self._dirstate is not None:
 
218
            return self._dirstate
 
219
        local_path = self.bzrdir.get_workingtree_transport(None
 
220
            ).local_abspath('dirstate')
 
221
        self._dirstate = dirstate.DirState.on_file(local_path,
 
222
            self._sha1_provider())
 
223
        return self._dirstate
 
224
 
 
225
    def _sha1_provider(self):
 
226
        """A function that returns a SHA1Provider suitable for this tree.
 
227
 
 
228
        :return: None if content filtering is not supported by this tree.
 
229
          Otherwise, a SHA1Provider is returned that sha's the canonical
 
230
          form of files, i.e. after read filters are applied.
 
231
        """
 
232
        if self.supports_content_filtering():
 
233
            return ContentFilterAwareSHA1Provider(self)
 
234
        else:
 
235
            return None
 
236
 
 
237
    def filter_unversioned_files(self, paths):
 
238
        """Filter out paths that are versioned.
 
239
 
 
240
        :return: set of paths.
 
241
        """
 
242
        # TODO: make a generic multi-bisect routine roughly that should list
 
243
        # the paths, then process one half at a time recursively, and feed the
 
244
        # results of each bisect in further still
 
245
        paths = sorted(paths)
 
246
        result = set()
 
247
        state = self.current_dirstate()
 
248
        # TODO we want a paths_to_dirblocks helper I think
 
249
        for path in paths:
 
250
            dirname, basename = os.path.split(path.encode('utf8'))
 
251
            _, _, _, path_is_versioned = state._get_block_entry_index(
 
252
                dirname, basename, 0)
 
253
            if not path_is_versioned:
 
254
                result.add(path)
 
255
        return result
 
256
 
 
257
    def flush(self):
 
258
        """Write all cached data to disk."""
 
259
        if self._control_files._lock_mode != 'w':
 
260
            raise errors.NotWriteLocked(self)
 
261
        self.current_dirstate().save()
 
262
        self._inventory = None
 
263
        self._dirty = False
 
264
 
 
265
    @needs_tree_write_lock
 
266
    def _gather_kinds(self, files, kinds):
 
267
        """See MutableTree._gather_kinds."""
 
268
        for pos, f in enumerate(files):
 
269
            if kinds[pos] is None:
 
270
                kinds[pos] = self._kind(f)
 
271
 
 
272
    def _generate_inventory(self):
 
273
        """Create and set self.inventory from the dirstate object.
 
274
 
 
275
        This is relatively expensive: we have to walk the entire dirstate.
 
276
        Ideally we would not, and can deprecate this function.
 
277
        """
 
278
        #: uncomment to trap on inventory requests.
 
279
        # import pdb;pdb.set_trace()
 
280
        state = self.current_dirstate()
 
281
        state._read_dirblocks_if_needed()
 
282
        root_key, current_entry = self._get_entry(path='')
 
283
        current_id = root_key[2]
 
284
        if not (current_entry[0][0] == 'd'): # directory
 
285
            raise AssertionError(current_entry)
 
286
        inv = Inventory(root_id=current_id)
 
287
        # Turn some things into local variables
 
288
        minikind_to_kind = dirstate.DirState._minikind_to_kind
 
289
        factory = entry_factory
 
290
        utf8_decode = cache_utf8._utf8_decode
 
291
        inv_byid = inv._byid
 
292
        # we could do this straight out of the dirstate; it might be fast
 
293
        # and should be profiled - RBC 20070216
 
294
        parent_ies = {'' : inv.root}
 
295
        for block in state._dirblocks[1:]: # skip the root
 
296
            dirname = block[0]
 
297
            try:
 
298
                parent_ie = parent_ies[dirname]
 
299
            except KeyError:
 
300
                # all the paths in this block are not versioned in this tree
 
301
                continue
 
302
            for key, entry in block[1]:
 
303
                minikind, link_or_sha1, size, executable, stat = entry[0]
 
304
                if minikind in ('a', 'r'): # absent, relocated
 
305
                    # a parent tree only entry
 
306
                    continue
 
307
                name = key[1]
 
308
                name_unicode = utf8_decode(name)[0]
 
309
                file_id = key[2]
 
310
                kind = minikind_to_kind[minikind]
 
311
                inv_entry = factory[kind](file_id, name_unicode,
 
312
                                          parent_ie.file_id)
 
313
                if kind == 'file':
 
314
                    # This is only needed on win32, where this is the only way
 
315
                    # we know the executable bit.
 
316
                    inv_entry.executable = executable
 
317
                    # not strictly needed: working tree
 
318
                    #inv_entry.text_size = size
 
319
                    #inv_entry.text_sha1 = sha1
 
320
                elif kind == 'directory':
 
321
                    # add this entry to the parent map.
 
322
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
 
323
                elif kind == 'tree-reference':
 
324
                    if not self._repo_supports_tree_reference:
 
325
                        raise errors.UnsupportedOperation(
 
326
                            self._generate_inventory,
 
327
                            self.branch.repository)
 
328
                    inv_entry.reference_revision = link_or_sha1 or None
 
329
                elif kind != 'symlink':
 
330
                    raise AssertionError("unknown kind %r" % kind)
 
331
                # These checks cost us around 40ms on a 55k entry tree
 
332
                if file_id in inv_byid:
 
333
                    raise AssertionError('file_id %s already in'
 
334
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
 
335
                if name_unicode in parent_ie.children:
 
336
                    raise AssertionError('name %r already in parent'
 
337
                        % (name_unicode,))
 
338
                inv_byid[file_id] = inv_entry
 
339
                parent_ie.children[name_unicode] = inv_entry
 
340
        self._inventory = inv
 
341
 
 
342
    def _get_entry(self, file_id=None, path=None):
 
343
        """Get the dirstate row for file_id or path.
 
344
 
 
345
        If either file_id or path is supplied, it is used as the key to lookup.
 
346
        If both are supplied, the fastest lookup is used, and an error is
 
347
        raised if they do not both point at the same row.
 
348
 
 
349
        :param file_id: An optional unicode file_id to be looked up.
 
350
        :param path: An optional unicode path to be looked up.
 
351
        :return: The dirstate row tuple for path/file_id, or (None, None)
 
352
        """
 
353
        if file_id is None and path is None:
 
354
            raise errors.BzrError('must supply file_id or path')
 
355
        state = self.current_dirstate()
 
356
        if path is not None:
 
357
            path = path.encode('utf8')
 
358
        return state._get_entry(0, fileid_utf8=file_id, path_utf8=path)
 
359
 
 
360
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
361
        # check file id is valid unconditionally.
 
362
        entry = self._get_entry(file_id=file_id, path=path)
 
363
        if entry[0] is None:
 
364
            raise errors.NoSuchId(self, file_id)
 
365
        if path is None:
 
366
            path = pathjoin(entry[0][0], entry[0][1]).decode('utf8')
 
367
 
 
368
        file_abspath = self.abspath(path)
 
369
        state = self.current_dirstate()
 
370
        if stat_value is None:
 
371
            try:
 
372
                stat_value = os.lstat(file_abspath)
 
373
            except OSError, e:
 
374
                if e.errno == errno.ENOENT:
 
375
                    return None
 
376
                else:
 
377
                    raise
 
378
        link_or_sha1 = dirstate.update_entry(state, entry, file_abspath,
 
379
            stat_value=stat_value)
 
380
        if entry[1][0][0] == 'f':
 
381
            if link_or_sha1 is None:
 
382
                file_obj, statvalue = self.get_file_with_stat(file_id, path)
 
383
                try:
 
384
                    sha1 = osutils.sha_file(file_obj)
 
385
                finally:
 
386
                    file_obj.close()
 
387
                self._observed_sha1(file_id, path, (sha1, statvalue))
 
388
                return sha1
 
389
            else:
 
390
                return link_or_sha1
 
391
        return None
 
392
 
 
393
    def _get_inventory(self):
 
394
        """Get the inventory for the tree. This is only valid within a lock."""
 
395
        if 'evil' in debug.debug_flags:
 
396
            trace.mutter_callsite(2,
 
397
                "accessing .inventory forces a size of tree translation.")
 
398
        if self._inventory is not None:
 
399
            return self._inventory
 
400
        self._must_be_locked()
 
401
        self._generate_inventory()
 
402
        return self._inventory
 
403
 
 
404
    inventory = property(_get_inventory,
 
405
                         doc="Inventory of this Tree")
 
406
 
 
407
    @needs_read_lock
 
408
    def get_parent_ids(self):
 
409
        """See Tree.get_parent_ids.
 
410
 
 
411
        This implementation requests the ids list from the dirstate file.
 
412
        """
 
413
        return self.current_dirstate().get_parent_ids()
 
414
 
 
415
    def get_reference_revision(self, file_id, path=None):
 
416
        # referenced tree's revision is whatever's currently there
 
417
        return self.get_nested_tree(file_id, path).last_revision()
 
418
 
 
419
    def get_nested_tree(self, file_id, path=None):
 
420
        if path is None:
 
421
            path = self.id2path(file_id)
 
422
        # else: check file_id is at path?
 
423
        return WorkingTree.open(self.abspath(path))
 
424
 
 
425
    @needs_read_lock
 
426
    def get_root_id(self):
 
427
        """Return the id of this trees root"""
 
428
        return self._get_entry(path='')[0][2]
 
429
 
 
430
    def has_id(self, file_id):
 
431
        state = self.current_dirstate()
 
432
        row, parents = self._get_entry(file_id=file_id)
 
433
        if row is None:
 
434
            return False
 
435
        return osutils.lexists(pathjoin(
 
436
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
 
437
 
 
438
    def has_or_had_id(self, file_id):
 
439
        state = self.current_dirstate()
 
440
        row, parents = self._get_entry(file_id=file_id)
 
441
        return row is not None
 
442
 
 
443
    @needs_read_lock
 
444
    def id2path(self, file_id):
 
445
        "Convert a file-id to a path."
 
446
        state = self.current_dirstate()
 
447
        entry = self._get_entry(file_id=file_id)
 
448
        if entry == (None, None):
 
449
            raise errors.NoSuchId(tree=self, file_id=file_id)
 
450
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
451
        return path_utf8.decode('utf8')
 
452
 
 
453
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
 
454
        entry = self._get_entry(path=path)
 
455
        if entry == (None, None):
 
456
            return False # Missing entries are not executable
 
457
        return entry[1][0][3] # Executable?
 
458
 
 
459
    if not osutils.supports_executable():
 
460
        def is_executable(self, file_id, path=None):
 
461
            """Test if a file is executable or not.
 
462
 
 
463
            Note: The caller is expected to take a read-lock before calling this.
 
464
            """
 
465
            entry = self._get_entry(file_id=file_id, path=path)
 
466
            if entry == (None, None):
 
467
                return False
 
468
            return entry[1][0][3]
 
469
 
 
470
        _is_executable_from_path_and_stat = \
 
471
            _is_executable_from_path_and_stat_from_basis
 
472
    else:
 
473
        def is_executable(self, file_id, path=None):
 
474
            """Test if a file is executable or not.
 
475
 
 
476
            Note: The caller is expected to take a read-lock before calling this.
 
477
            """
 
478
            self._must_be_locked()
 
479
            if not path:
 
480
                path = self.id2path(file_id)
 
481
            mode = os.lstat(self.abspath(path)).st_mode
 
482
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
483
 
 
484
    def all_file_ids(self):
 
485
        """See Tree.iter_all_file_ids"""
 
486
        self._must_be_locked()
 
487
        result = set()
 
488
        for key, tree_details in self.current_dirstate()._iter_entries():
 
489
            if tree_details[0][0] in ('a', 'r'): # relocated
 
490
                continue
 
491
            result.add(key[2])
 
492
        return result
 
493
 
 
494
    @needs_read_lock
 
495
    def __iter__(self):
 
496
        """Iterate through file_ids for this tree.
 
497
 
 
498
        file_ids are in a WorkingTree if they are in the working inventory
 
499
        and the working file exists.
 
500
        """
 
501
        result = []
 
502
        for key, tree_details in self.current_dirstate()._iter_entries():
 
503
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
 
504
                # not relevant to the working tree
 
505
                continue
 
506
            path = pathjoin(self.basedir, key[0].decode('utf8'), key[1].decode('utf8'))
 
507
            if osutils.lexists(path):
 
508
                result.append(key[2])
 
509
        return iter(result)
 
510
 
 
511
    def iter_references(self):
 
512
        if not self._repo_supports_tree_reference:
 
513
            # When the repo doesn't support references, we will have nothing to
 
514
            # return
 
515
            return
 
516
        for key, tree_details in self.current_dirstate()._iter_entries():
 
517
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
 
518
                # not relevant to the working tree
 
519
                continue
 
520
            if not key[1]:
 
521
                # the root is not a reference.
 
522
                continue
 
523
            relpath = pathjoin(key[0].decode('utf8'), key[1].decode('utf8'))
 
524
            try:
 
525
                if self._kind(relpath) == 'tree-reference':
 
526
                    yield relpath, key[2]
 
527
            except errors.NoSuchFile:
 
528
                # path is missing on disk.
 
529
                continue
 
530
 
 
531
    def _observed_sha1(self, file_id, path, (sha1, statvalue)):
 
532
        """See MutableTree._observed_sha1."""
 
533
        state = self.current_dirstate()
 
534
        entry = self._get_entry(file_id=file_id, path=path)
 
535
        state._observed_sha1(entry, sha1, statvalue)
 
536
 
 
537
    def kind(self, file_id):
 
538
        """Return the kind of a file.
 
539
 
 
540
        This is always the actual kind that's on disk, regardless of what it
 
541
        was added as.
 
542
 
 
543
        Note: The caller is expected to take a read-lock before calling this.
 
544
        """
 
545
        relpath = self.id2path(file_id)
 
546
        if relpath is None:
 
547
            raise AssertionError(
 
548
                "path for id {%s} is None!" % file_id)
 
549
        return self._kind(relpath)
 
550
 
 
551
    def _kind(self, relpath):
 
552
        abspath = self.abspath(relpath)
 
553
        kind = file_kind(abspath)
 
554
        if (self._repo_supports_tree_reference and kind == 'directory'):
 
555
            entry = self._get_entry(path=relpath)
 
556
            if entry[1] is not None:
 
557
                if entry[1][0][0] == 't':
 
558
                    kind = 'tree-reference'
 
559
        return kind
 
560
 
 
561
    @needs_read_lock
 
562
    def _last_revision(self):
 
563
        """See Mutable.last_revision."""
 
564
        parent_ids = self.current_dirstate().get_parent_ids()
 
565
        if parent_ids:
 
566
            return parent_ids[0]
 
567
        else:
 
568
            return _mod_revision.NULL_REVISION
 
569
 
 
570
    def lock_read(self):
 
571
        """See Branch.lock_read, and WorkingTree.unlock.
 
572
 
 
573
        :return: A bzrlib.lock.LogicalLockResult.
 
574
        """
 
575
        self.branch.lock_read()
 
576
        try:
 
577
            self._control_files.lock_read()
 
578
            try:
 
579
                state = self.current_dirstate()
 
580
                if not state._lock_token:
 
581
                    state.lock_read()
 
582
                # set our support for tree references from the repository in
 
583
                # use.
 
584
                self._repo_supports_tree_reference = getattr(
 
585
                    self.branch.repository._format, "supports_tree_reference",
 
586
                    False)
 
587
            except:
 
588
                self._control_files.unlock()
 
589
                raise
 
590
        except:
 
591
            self.branch.unlock()
 
592
            raise
 
593
        return LogicalLockResult(self.unlock)
 
594
 
 
595
    def _lock_self_write(self):
 
596
        """This should be called after the branch is locked."""
 
597
        try:
 
598
            self._control_files.lock_write()
 
599
            try:
 
600
                state = self.current_dirstate()
 
601
                if not state._lock_token:
 
602
                    state.lock_write()
 
603
                # set our support for tree references from the repository in
 
604
                # use.
 
605
                self._repo_supports_tree_reference = getattr(
 
606
                    self.branch.repository._format, "supports_tree_reference",
 
607
                    False)
 
608
            except:
 
609
                self._control_files.unlock()
 
610
                raise
 
611
        except:
 
612
            self.branch.unlock()
 
613
            raise
 
614
        return LogicalLockResult(self.unlock)
 
615
 
 
616
    def lock_tree_write(self):
 
617
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
 
618
 
 
619
        :return: A bzrlib.lock.LogicalLockResult.
 
620
        """
 
621
        self.branch.lock_read()
 
622
        return self._lock_self_write()
 
623
 
 
624
    def lock_write(self):
 
625
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
626
 
 
627
        :return: A bzrlib.lock.LogicalLockResult.
 
628
        """
 
629
        self.branch.lock_write()
 
630
        return self._lock_self_write()
 
631
 
 
632
    @needs_tree_write_lock
 
633
    def move(self, from_paths, to_dir, after=False):
 
634
        """See WorkingTree.move()."""
 
635
        result = []
 
636
        if not from_paths:
 
637
            return result
 
638
        state = self.current_dirstate()
 
639
        if isinstance(from_paths, basestring):
 
640
            raise ValueError()
 
641
        to_dir_utf8 = to_dir.encode('utf8')
 
642
        to_entry_dirname, to_basename = os.path.split(to_dir_utf8)
 
643
        id_index = state._get_id_index()
 
644
        # check destination directory
 
645
        # get the details for it
 
646
        to_entry_block_index, to_entry_entry_index, dir_present, entry_present = \
 
647
            state._get_block_entry_index(to_entry_dirname, to_basename, 0)
 
648
        if not entry_present:
 
649
            raise errors.BzrMoveFailedError('', to_dir,
 
650
                errors.NotVersionedError(to_dir))
 
651
        to_entry = state._dirblocks[to_entry_block_index][1][to_entry_entry_index]
 
652
        # get a handle on the block itself.
 
653
        to_block_index = state._ensure_block(
 
654
            to_entry_block_index, to_entry_entry_index, to_dir_utf8)
 
655
        to_block = state._dirblocks[to_block_index]
 
656
        to_abs = self.abspath(to_dir)
 
657
        if not isdir(to_abs):
 
658
            raise errors.BzrMoveFailedError('',to_dir,
 
659
                errors.NotADirectory(to_abs))
 
660
 
 
661
        if to_entry[1][0][0] != 'd':
 
662
            raise errors.BzrMoveFailedError('',to_dir,
 
663
                errors.NotADirectory(to_abs))
 
664
 
 
665
        if self._inventory is not None:
 
666
            update_inventory = True
 
667
            inv = self.inventory
 
668
            to_dir_id = to_entry[0][2]
 
669
            to_dir_ie = inv[to_dir_id]
 
670
        else:
 
671
            update_inventory = False
 
672
 
 
673
        rollbacks = []
 
674
        def move_one(old_entry, from_path_utf8, minikind, executable,
 
675
                     fingerprint, packed_stat, size,
 
676
                     to_block, to_key, to_path_utf8):
 
677
            state._make_absent(old_entry)
 
678
            from_key = old_entry[0]
 
679
            rollbacks.append(
 
680
                lambda:state.update_minimal(from_key,
 
681
                    minikind,
 
682
                    executable=executable,
 
683
                    fingerprint=fingerprint,
 
684
                    packed_stat=packed_stat,
 
685
                    size=size,
 
686
                    path_utf8=from_path_utf8))
 
687
            state.update_minimal(to_key,
 
688
                    minikind,
 
689
                    executable=executable,
 
690
                    fingerprint=fingerprint,
 
691
                    packed_stat=packed_stat,
 
692
                    size=size,
 
693
                    path_utf8=to_path_utf8)
 
694
            added_entry_index, _ = state._find_entry_index(to_key, to_block[1])
 
695
            new_entry = to_block[1][added_entry_index]
 
696
            rollbacks.append(lambda:state._make_absent(new_entry))
 
697
 
 
698
        for from_rel in from_paths:
 
699
            # from_rel is 'pathinroot/foo/bar'
 
700
            from_rel_utf8 = from_rel.encode('utf8')
 
701
            from_dirname, from_tail = osutils.split(from_rel)
 
702
            from_dirname, from_tail_utf8 = osutils.split(from_rel_utf8)
 
703
            from_entry = self._get_entry(path=from_rel)
 
704
            if from_entry == (None, None):
 
705
                raise errors.BzrMoveFailedError(from_rel,to_dir,
 
706
                    errors.NotVersionedError(path=from_rel))
 
707
 
 
708
            from_id = from_entry[0][2]
 
709
            to_rel = pathjoin(to_dir, from_tail)
 
710
            to_rel_utf8 = pathjoin(to_dir_utf8, from_tail_utf8)
 
711
            item_to_entry = self._get_entry(path=to_rel)
 
712
            if item_to_entry != (None, None):
 
713
                raise errors.BzrMoveFailedError(from_rel, to_rel,
 
714
                    "Target is already versioned.")
 
715
 
 
716
            if from_rel == to_rel:
 
717
                raise errors.BzrMoveFailedError(from_rel, to_rel,
 
718
                    "Source and target are identical.")
 
719
 
 
720
            from_missing = not self.has_filename(from_rel)
 
721
            to_missing = not self.has_filename(to_rel)
 
722
            if after:
 
723
                move_file = False
 
724
            else:
 
725
                move_file = True
 
726
            if to_missing:
 
727
                if not move_file:
 
728
                    raise errors.BzrMoveFailedError(from_rel, to_rel,
 
729
                        errors.NoSuchFile(path=to_rel,
 
730
                        extra="New file has not been created yet"))
 
731
                elif from_missing:
 
732
                    # neither path exists
 
733
                    raise errors.BzrRenameFailedError(from_rel, to_rel,
 
734
                        errors.PathsDoNotExist(paths=(from_rel, to_rel)))
 
735
            else:
 
736
                if from_missing: # implicitly just update our path mapping
 
737
                    move_file = False
 
738
                elif not after:
 
739
                    raise errors.RenameFailedFilesExist(from_rel, to_rel)
 
740
 
 
741
            rollbacks = []
 
742
            def rollback_rename():
 
743
                """A single rename has failed, roll it back."""
 
744
                # roll back everything, even if we encounter trouble doing one
 
745
                # of them.
 
746
                #
 
747
                # TODO: at least log the other exceptions rather than just
 
748
                # losing them mbp 20070307
 
749
                exc_info = None
 
750
                for rollback in reversed(rollbacks):
 
751
                    try:
 
752
                        rollback()
 
753
                    except Exception, e:
 
754
                        exc_info = sys.exc_info()
 
755
                if exc_info:
 
756
                    raise exc_info[0], exc_info[1], exc_info[2]
 
757
 
 
758
            # perform the disk move first - its the most likely failure point.
 
759
            if move_file:
 
760
                from_rel_abs = self.abspath(from_rel)
 
761
                to_rel_abs = self.abspath(to_rel)
 
762
                try:
 
763
                    osutils.rename(from_rel_abs, to_rel_abs)
 
764
                except OSError, e:
 
765
                    raise errors.BzrMoveFailedError(from_rel, to_rel, e[1])
 
766
                rollbacks.append(lambda: osutils.rename(to_rel_abs, from_rel_abs))
 
767
            try:
 
768
                # perform the rename in the inventory next if needed: its easy
 
769
                # to rollback
 
770
                if update_inventory:
 
771
                    # rename the entry
 
772
                    from_entry = inv[from_id]
 
773
                    current_parent = from_entry.parent_id
 
774
                    inv.rename(from_id, to_dir_id, from_tail)
 
775
                    rollbacks.append(
 
776
                        lambda: inv.rename(from_id, current_parent, from_tail))
 
777
                # finally do the rename in the dirstate, which is a little
 
778
                # tricky to rollback, but least likely to need it.
 
779
                old_block_index, old_entry_index, dir_present, file_present = \
 
780
                    state._get_block_entry_index(from_dirname, from_tail_utf8, 0)
 
781
                old_block = state._dirblocks[old_block_index][1]
 
782
                old_entry = old_block[old_entry_index]
 
783
                from_key, old_entry_details = old_entry
 
784
                cur_details = old_entry_details[0]
 
785
                # remove the old row
 
786
                to_key = ((to_block[0],) + from_key[1:3])
 
787
                minikind = cur_details[0]
 
788
                move_one(old_entry, from_path_utf8=from_rel_utf8,
 
789
                         minikind=minikind,
 
790
                         executable=cur_details[3],
 
791
                         fingerprint=cur_details[1],
 
792
                         packed_stat=cur_details[4],
 
793
                         size=cur_details[2],
 
794
                         to_block=to_block,
 
795
                         to_key=to_key,
 
796
                         to_path_utf8=to_rel_utf8)
 
797
 
 
798
                if minikind == 'd':
 
799
                    def update_dirblock(from_dir, to_key, to_dir_utf8):
 
800
                        """Recursively update all entries in this dirblock."""
 
801
                        if from_dir == '':
 
802
                            raise AssertionError("renaming root not supported")
 
803
                        from_key = (from_dir, '')
 
804
                        from_block_idx, present = \
 
805
                            state._find_block_index_from_key(from_key)
 
806
                        if not present:
 
807
                            # This is the old record, if it isn't present, then
 
808
                            # there is theoretically nothing to update.
 
809
                            # (Unless it isn't present because of lazy loading,
 
810
                            # but we don't do that yet)
 
811
                            return
 
812
                        from_block = state._dirblocks[from_block_idx]
 
813
                        to_block_index, to_entry_index, _, _ = \
 
814
                            state._get_block_entry_index(to_key[0], to_key[1], 0)
 
815
                        to_block_index = state._ensure_block(
 
816
                            to_block_index, to_entry_index, to_dir_utf8)
 
817
                        to_block = state._dirblocks[to_block_index]
 
818
 
 
819
                        # Grab a copy since move_one may update the list.
 
820
                        for entry in from_block[1][:]:
 
821
                            if not (entry[0][0] == from_dir):
 
822
                                raise AssertionError()
 
823
                            cur_details = entry[1][0]
 
824
                            to_key = (to_dir_utf8, entry[0][1], entry[0][2])
 
825
                            from_path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
826
                            to_path_utf8 = osutils.pathjoin(to_dir_utf8, entry[0][1])
 
827
                            minikind = cur_details[0]
 
828
                            if minikind in 'ar':
 
829
                                # Deleted children of a renamed directory
 
830
                                # Do not need to be updated.
 
831
                                # Children that have been renamed out of this
 
832
                                # directory should also not be updated
 
833
                                continue
 
834
                            move_one(entry, from_path_utf8=from_path_utf8,
 
835
                                     minikind=minikind,
 
836
                                     executable=cur_details[3],
 
837
                                     fingerprint=cur_details[1],
 
838
                                     packed_stat=cur_details[4],
 
839
                                     size=cur_details[2],
 
840
                                     to_block=to_block,
 
841
                                     to_key=to_key,
 
842
                                     to_path_utf8=to_path_utf8)
 
843
                            if minikind == 'd':
 
844
                                # We need to move all the children of this
 
845
                                # entry
 
846
                                update_dirblock(from_path_utf8, to_key,
 
847
                                                to_path_utf8)
 
848
                    update_dirblock(from_rel_utf8, to_key, to_rel_utf8)
 
849
            except:
 
850
                rollback_rename()
 
851
                raise
 
852
            result.append((from_rel, to_rel))
 
853
            state._dirblock_state = dirstate.DirState.IN_MEMORY_MODIFIED
 
854
            self._make_dirty(reset_inventory=False)
 
855
 
 
856
        return result
 
857
 
 
858
    def _must_be_locked(self):
 
859
        if not self._control_files._lock_count:
 
860
            raise errors.ObjectNotLocked(self)
 
861
 
 
862
    def _new_tree(self):
 
863
        """Initialize the state in this tree to be a new tree."""
 
864
        self._dirty = True
 
865
 
 
866
    @needs_read_lock
 
867
    def path2id(self, path):
 
868
        """Return the id for path in this tree."""
 
869
        path = path.strip('/')
 
870
        entry = self._get_entry(path=path)
 
871
        if entry == (None, None):
 
872
            return None
 
873
        return entry[0][2]
 
874
 
 
875
    def paths2ids(self, paths, trees=[], require_versioned=True):
 
876
        """See Tree.paths2ids().
 
877
 
 
878
        This specialisation fast-paths the case where all the trees are in the
 
879
        dirstate.
 
880
        """
 
881
        if paths is None:
 
882
            return None
 
883
        parents = self.get_parent_ids()
 
884
        for tree in trees:
 
885
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
 
886
                parents):
 
887
                return super(DirStateWorkingTree, self).paths2ids(paths,
 
888
                    trees, require_versioned)
 
889
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
 
890
        # -- make all paths utf8 --
 
891
        paths_utf8 = set()
 
892
        for path in paths:
 
893
            paths_utf8.add(path.encode('utf8'))
 
894
        paths = paths_utf8
 
895
        # -- paths is now a utf8 path set --
 
896
        # -- get the state object and prepare it.
 
897
        state = self.current_dirstate()
 
898
        if False and (state._dirblock_state == dirstate.DirState.NOT_IN_MEMORY
 
899
            and '' not in paths):
 
900
            paths2ids = self._paths2ids_using_bisect
 
901
        else:
 
902
            paths2ids = self._paths2ids_in_memory
 
903
        return paths2ids(paths, search_indexes,
 
904
                         require_versioned=require_versioned)
 
905
 
 
906
    def _paths2ids_in_memory(self, paths, search_indexes,
 
907
                             require_versioned=True):
 
908
        state = self.current_dirstate()
 
909
        state._read_dirblocks_if_needed()
 
910
        def _entries_for_path(path):
 
911
            """Return a list with all the entries that match path for all ids.
 
912
            """
 
913
            dirname, basename = os.path.split(path)
 
914
            key = (dirname, basename, '')
 
915
            block_index, present = state._find_block_index_from_key(key)
 
916
            if not present:
 
917
                # the block which should contain path is absent.
 
918
                return []
 
919
            result = []
 
920
            block = state._dirblocks[block_index][1]
 
921
            entry_index, _ = state._find_entry_index(key, block)
 
922
            # we may need to look at multiple entries at this path: walk while the paths match.
 
923
            while (entry_index < len(block) and
 
924
                block[entry_index][0][0:2] == key[0:2]):
 
925
                result.append(block[entry_index])
 
926
                entry_index += 1
 
927
            return result
 
928
        if require_versioned:
 
929
            # -- check all supplied paths are versioned in a search tree. --
 
930
            all_versioned = True
 
931
            for path in paths:
 
932
                path_entries = _entries_for_path(path)
 
933
                if not path_entries:
 
934
                    # this specified path is not present at all: error
 
935
                    all_versioned = False
 
936
                    break
 
937
                found_versioned = False
 
938
                # for each id at this path
 
939
                for entry in path_entries:
 
940
                    # for each tree.
 
941
                    for index in search_indexes:
 
942
                        if entry[1][index][0] != 'a': # absent
 
943
                            found_versioned = True
 
944
                            # all good: found a versioned cell
 
945
                            break
 
946
                if not found_versioned:
 
947
                    # none of the indexes was not 'absent' at all ids for this
 
948
                    # path.
 
949
                    all_versioned = False
 
950
                    break
 
951
            if not all_versioned:
 
952
                raise errors.PathsNotVersionedError(paths)
 
953
        # -- remove redundancy in supplied paths to prevent over-scanning --
 
954
        search_paths = osutils.minimum_path_selection(paths)
 
955
        # sketch:
 
956
        # for all search_indexs in each path at or under each element of
 
957
        # search_paths, if the detail is relocated: add the id, and add the
 
958
        # relocated path as one to search if its not searched already. If the
 
959
        # detail is not relocated, add the id.
 
960
        searched_paths = set()
 
961
        found_ids = set()
 
962
        def _process_entry(entry):
 
963
            """Look at search_indexes within entry.
 
964
 
 
965
            If a specific tree's details are relocated, add the relocation
 
966
            target to search_paths if not searched already. If it is absent, do
 
967
            nothing. Otherwise add the id to found_ids.
 
968
            """
 
969
            for index in search_indexes:
 
970
                if entry[1][index][0] == 'r': # relocated
 
971
                    if not osutils.is_inside_any(searched_paths, entry[1][index][1]):
 
972
                        search_paths.add(entry[1][index][1])
 
973
                elif entry[1][index][0] != 'a': # absent
 
974
                    found_ids.add(entry[0][2])
 
975
        while search_paths:
 
976
            current_root = search_paths.pop()
 
977
            searched_paths.add(current_root)
 
978
            # process the entries for this containing directory: the rest will be
 
979
            # found by their parents recursively.
 
980
            root_entries = _entries_for_path(current_root)
 
981
            if not root_entries:
 
982
                # this specified path is not present at all, skip it.
 
983
                continue
 
984
            for entry in root_entries:
 
985
                _process_entry(entry)
 
986
            initial_key = (current_root, '', '')
 
987
            block_index, _ = state._find_block_index_from_key(initial_key)
 
988
            while (block_index < len(state._dirblocks) and
 
989
                osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
990
                for entry in state._dirblocks[block_index][1]:
 
991
                    _process_entry(entry)
 
992
                block_index += 1
 
993
        return found_ids
 
994
 
 
995
    def _paths2ids_using_bisect(self, paths, search_indexes,
 
996
                                require_versioned=True):
 
997
        state = self.current_dirstate()
 
998
        found_ids = set()
 
999
 
 
1000
        split_paths = sorted(osutils.split(p) for p in paths)
 
1001
        found = state._bisect_recursive(split_paths)
 
1002
 
 
1003
        if require_versioned:
 
1004
            found_dir_names = set(dir_name_id[:2] for dir_name_id in found)
 
1005
            for dir_name in split_paths:
 
1006
                if dir_name not in found_dir_names:
 
1007
                    raise errors.PathsNotVersionedError(paths)
 
1008
 
 
1009
        for dir_name_id, trees_info in found.iteritems():
 
1010
            for index in search_indexes:
 
1011
                if trees_info[index][0] not in ('r', 'a'):
 
1012
                    found_ids.add(dir_name_id[2])
 
1013
        return found_ids
 
1014
 
 
1015
    def read_working_inventory(self):
 
1016
        """Read the working inventory.
 
1017
 
 
1018
        This is a meaningless operation for dirstate, but we obey it anyhow.
 
1019
        """
 
1020
        return self.inventory
 
1021
 
 
1022
    @needs_read_lock
 
1023
    def revision_tree(self, revision_id):
 
1024
        """See Tree.revision_tree.
 
1025
 
 
1026
        WorkingTree4 supplies revision_trees for any basis tree.
 
1027
        """
 
1028
        dirstate = self.current_dirstate()
 
1029
        parent_ids = dirstate.get_parent_ids()
 
1030
        if revision_id not in parent_ids:
 
1031
            raise errors.NoSuchRevisionInTree(self, revision_id)
 
1032
        if revision_id in dirstate.get_ghosts():
 
1033
            raise errors.NoSuchRevisionInTree(self, revision_id)
 
1034
        return DirStateRevisionTree(dirstate, revision_id,
 
1035
            self.branch.repository)
 
1036
 
 
1037
    @needs_tree_write_lock
 
1038
    def set_last_revision(self, new_revision):
 
1039
        """Change the last revision in the working tree."""
 
1040
        parents = self.get_parent_ids()
 
1041
        if new_revision in (_mod_revision.NULL_REVISION, None):
 
1042
            if len(parents) >= 2:
 
1043
                raise AssertionError(
 
1044
                    "setting the last parent to none with a pending merge is "
 
1045
                    "unsupported.")
 
1046
            self.set_parent_ids([])
 
1047
        else:
 
1048
            self.set_parent_ids([new_revision] + parents[1:],
 
1049
                allow_leftmost_as_ghost=True)
 
1050
 
 
1051
    @needs_tree_write_lock
 
1052
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
 
1053
        """Set the parent ids to revision_ids.
 
1054
 
 
1055
        See also set_parent_trees. This api will try to retrieve the tree data
 
1056
        for each element of revision_ids from the trees repository. If you have
 
1057
        tree data already available, it is more efficient to use
 
1058
        set_parent_trees rather than set_parent_ids. set_parent_ids is however
 
1059
        an easier API to use.
 
1060
 
 
1061
        :param revision_ids: The revision_ids to set as the parent ids of this
 
1062
            working tree. Any of these may be ghosts.
 
1063
        """
 
1064
        trees = []
 
1065
        for revision_id in revision_ids:
 
1066
            try:
 
1067
                revtree = self.branch.repository.revision_tree(revision_id)
 
1068
                # TODO: jam 20070213 KnitVersionedFile raises
 
1069
                #       RevisionNotPresent rather than NoSuchRevision if a
 
1070
                #       given revision_id is not present. Should Repository be
 
1071
                #       catching it and re-raising NoSuchRevision?
 
1072
            except (errors.NoSuchRevision, errors.RevisionNotPresent):
 
1073
                revtree = None
 
1074
            trees.append((revision_id, revtree))
 
1075
        self.set_parent_trees(trees,
 
1076
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
1077
 
 
1078
    @needs_tree_write_lock
 
1079
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
1080
        """Set the parents of the working tree.
 
1081
 
 
1082
        :param parents_list: A list of (revision_id, tree) tuples.
 
1083
            If tree is None, then that element is treated as an unreachable
 
1084
            parent tree - i.e. a ghost.
 
1085
        """
 
1086
        dirstate = self.current_dirstate()
 
1087
        if len(parents_list) > 0:
 
1088
            if not allow_leftmost_as_ghost and parents_list[0][1] is None:
 
1089
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
 
1090
        real_trees = []
 
1091
        ghosts = []
 
1092
 
 
1093
        parent_ids = [rev_id for rev_id, tree in parents_list]
 
1094
        graph = self.branch.repository.get_graph()
 
1095
        heads = graph.heads(parent_ids)
 
1096
        accepted_revisions = set()
 
1097
 
 
1098
        # convert absent trees to the null tree, which we convert back to
 
1099
        # missing on access.
 
1100
        for rev_id, tree in parents_list:
 
1101
            if len(accepted_revisions) > 0:
 
1102
                # we always accept the first tree
 
1103
                if rev_id in accepted_revisions or rev_id not in heads:
 
1104
                    # We have already included either this tree, or its
 
1105
                    # descendent, so we skip it.
 
1106
                    continue
 
1107
            _mod_revision.check_not_reserved_id(rev_id)
 
1108
            if tree is not None:
 
1109
                real_trees.append((rev_id, tree))
 
1110
            else:
 
1111
                real_trees.append((rev_id,
 
1112
                    self.branch.repository.revision_tree(
 
1113
                        _mod_revision.NULL_REVISION)))
 
1114
                ghosts.append(rev_id)
 
1115
            accepted_revisions.add(rev_id)
 
1116
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
 
1117
        self._make_dirty(reset_inventory=False)
 
1118
 
 
1119
    def _set_root_id(self, file_id):
 
1120
        """See WorkingTree.set_root_id."""
 
1121
        state = self.current_dirstate()
 
1122
        state.set_path_id('', file_id)
 
1123
        if state._dirblock_state == dirstate.DirState.IN_MEMORY_MODIFIED:
 
1124
            self._make_dirty(reset_inventory=True)
 
1125
 
 
1126
    def _sha_from_stat(self, path, stat_result):
 
1127
        """Get a sha digest from the tree's stat cache.
 
1128
 
 
1129
        The default implementation assumes no stat cache is present.
 
1130
 
 
1131
        :param path: The path.
 
1132
        :param stat_result: The stat result being looked up.
 
1133
        """
 
1134
        return self.current_dirstate().sha1_from_stat(path, stat_result)
 
1135
 
 
1136
    @needs_read_lock
 
1137
    def supports_tree_reference(self):
 
1138
        return self._repo_supports_tree_reference
 
1139
 
 
1140
    def unlock(self):
 
1141
        """Unlock in format 4 trees needs to write the entire dirstate."""
 
1142
        # do non-implementation specific cleanup
 
1143
        self._cleanup()
 
1144
 
 
1145
        if self._control_files._lock_count == 1:
 
1146
            # eventually we should do signature checking during read locks for
 
1147
            # dirstate updates.
 
1148
            if self._control_files._lock_mode == 'w':
 
1149
                if self._dirty:
 
1150
                    self.flush()
 
1151
            if self._dirstate is not None:
 
1152
                # This is a no-op if there are no modifications.
 
1153
                self._dirstate.save()
 
1154
                self._dirstate.unlock()
 
1155
            # TODO: jam 20070301 We shouldn't have to wipe the dirstate at this
 
1156
            #       point. Instead, it could check if the header has been
 
1157
            #       modified when it is locked, and if not, it can hang on to
 
1158
            #       the data it has in memory.
 
1159
            self._dirstate = None
 
1160
            self._inventory = None
 
1161
        # reverse order of locking.
 
1162
        try:
 
1163
            return self._control_files.unlock()
 
1164
        finally:
 
1165
            self.branch.unlock()
 
1166
 
 
1167
    @needs_tree_write_lock
 
1168
    def unversion(self, file_ids):
 
1169
        """Remove the file ids in file_ids from the current versioned set.
 
1170
 
 
1171
        When a file_id is unversioned, all of its children are automatically
 
1172
        unversioned.
 
1173
 
 
1174
        :param file_ids: The file ids to stop versioning.
 
1175
        :raises: NoSuchId if any fileid is not currently versioned.
 
1176
        """
 
1177
        if not file_ids:
 
1178
            return
 
1179
        state = self.current_dirstate()
 
1180
        state._read_dirblocks_if_needed()
 
1181
        ids_to_unversion = set(file_ids)
 
1182
        paths_to_unversion = set()
 
1183
        # sketch:
 
1184
        # check if the root is to be unversioned, if so, assert for now.
 
1185
        # walk the state marking unversioned things as absent.
 
1186
        # if there are any un-unversioned ids at the end, raise
 
1187
        for key, details in state._dirblocks[0][1]:
 
1188
            if (details[0][0] not in ('a', 'r') and # absent or relocated
 
1189
                key[2] in ids_to_unversion):
 
1190
                # I haven't written the code to unversion / yet - it should be
 
1191
                # supported.
 
1192
                raise errors.BzrError('Unversioning the / is not currently supported')
 
1193
        block_index = 0
 
1194
        while block_index < len(state._dirblocks):
 
1195
            # process one directory at a time.
 
1196
            block = state._dirblocks[block_index]
 
1197
            # first check: is the path one to remove - it or its children
 
1198
            delete_block = False
 
1199
            for path in paths_to_unversion:
 
1200
                if (block[0].startswith(path) and
 
1201
                    (len(block[0]) == len(path) or
 
1202
                     block[0][len(path)] == '/')):
 
1203
                    # this entire block should be deleted - its the block for a
 
1204
                    # path to unversion; or the child of one
 
1205
                    delete_block = True
 
1206
                    break
 
1207
            # TODO: trim paths_to_unversion as we pass by paths
 
1208
            if delete_block:
 
1209
                # this block is to be deleted: process it.
 
1210
                # TODO: we can special case the no-parents case and
 
1211
                # just forget the whole block.
 
1212
                entry_index = 0
 
1213
                while entry_index < len(block[1]):
 
1214
                    entry = block[1][entry_index]
 
1215
                    if entry[1][0][0] in 'ar':
 
1216
                        # don't remove absent or renamed entries
 
1217
                        entry_index += 1
 
1218
                    else:
 
1219
                        # Mark this file id as having been removed
 
1220
                        ids_to_unversion.discard(entry[0][2])
 
1221
                        if not state._make_absent(entry):
 
1222
                            # The block has not shrunk.
 
1223
                            entry_index += 1
 
1224
                # go to the next block. (At the moment we dont delete empty
 
1225
                # dirblocks)
 
1226
                block_index += 1
 
1227
                continue
 
1228
            entry_index = 0
 
1229
            while entry_index < len(block[1]):
 
1230
                entry = block[1][entry_index]
 
1231
                if (entry[1][0][0] in ('a', 'r') or # absent, relocated
 
1232
                    # ^ some parent row.
 
1233
                    entry[0][2] not in ids_to_unversion):
 
1234
                    # ^ not an id to unversion
 
1235
                    entry_index += 1
 
1236
                    continue
 
1237
                if entry[1][0][0] == 'd':
 
1238
                    paths_to_unversion.add(pathjoin(entry[0][0], entry[0][1]))
 
1239
                if not state._make_absent(entry):
 
1240
                    entry_index += 1
 
1241
                # we have unversioned this id
 
1242
                ids_to_unversion.remove(entry[0][2])
 
1243
            block_index += 1
 
1244
        if ids_to_unversion:
 
1245
            raise errors.NoSuchId(self, iter(ids_to_unversion).next())
 
1246
        self._make_dirty(reset_inventory=False)
 
1247
        # have to change the legacy inventory too.
 
1248
        if self._inventory is not None:
 
1249
            for file_id in file_ids:
 
1250
                if self._inventory.has_id(file_id):
 
1251
                    self._inventory.remove_recursive_id(file_id)
 
1252
 
 
1253
    @needs_tree_write_lock
 
1254
    def rename_one(self, from_rel, to_rel, after=False):
 
1255
        """See WorkingTree.rename_one"""
 
1256
        self.flush()
 
1257
        WorkingTree.rename_one(self, from_rel, to_rel, after)
 
1258
 
 
1259
    @needs_tree_write_lock
 
1260
    def apply_inventory_delta(self, changes):
 
1261
        """See MutableTree.apply_inventory_delta"""
 
1262
        state = self.current_dirstate()
 
1263
        state.update_by_delta(changes)
 
1264
        self._make_dirty(reset_inventory=True)
 
1265
 
 
1266
    def update_basis_by_delta(self, new_revid, delta):
 
1267
        """See MutableTree.update_basis_by_delta."""
 
1268
        if self.last_revision() == new_revid:
 
1269
            raise AssertionError()
 
1270
        self.current_dirstate().update_basis_by_delta(delta, new_revid)
 
1271
 
 
1272
    @needs_read_lock
 
1273
    def _validate(self):
 
1274
        self._dirstate._validate()
 
1275
 
 
1276
    @needs_tree_write_lock
 
1277
    def _write_inventory(self, inv):
 
1278
        """Write inventory as the current inventory."""
 
1279
        if self._dirty:
 
1280
            raise AssertionError("attempting to write an inventory when the "
 
1281
                "dirstate is dirty will lose pending changes")
 
1282
        had_inventory = self._inventory is not None
 
1283
        # Setting self._inventory = None forces the dirstate to regenerate the
 
1284
        # working inventory. We do this because self.inventory may be inv, or
 
1285
        # may have been modified, and either case would prevent a clean delta
 
1286
        # being created.
 
1287
        self._inventory = None
 
1288
        # generate a delta,
 
1289
        delta = inv._make_delta(self.inventory)
 
1290
        # and apply it.
 
1291
        self.apply_inventory_delta(delta)
 
1292
        if had_inventory:
 
1293
            self._inventory = inv
 
1294
        self.flush()
 
1295
 
 
1296
    @needs_tree_write_lock
 
1297
    def reset_state(self, revision_ids=None):
 
1298
        """Reset the state of the working tree.
 
1299
 
 
1300
        This does a hard-reset to a last-known-good state. This is a way to
 
1301
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
 
1302
        """
 
1303
        if revision_ids is None:
 
1304
            revision_ids = self.get_parent_ids()
 
1305
        if not revision_ids:
 
1306
            base_tree = self.branch.repository.revision_tree(
 
1307
                _mod_revision.NULL_REVISION)
 
1308
            trees = []
 
1309
        else:
 
1310
            trees = zip(revision_ids,
 
1311
                        self.branch.repository.revision_trees(revision_ids))
 
1312
            base_tree = trees[0][1]
 
1313
        state = self.current_dirstate()
 
1314
        # We don't support ghosts yet
 
1315
        state.set_state_from_scratch(base_tree.inventory, trees, [])
 
1316
 
 
1317
 
 
1318
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
 
1319
 
 
1320
    def __init__(self, tree):
 
1321
        self.tree = tree
 
1322
 
 
1323
    def sha1(self, abspath):
 
1324
        """See dirstate.SHA1Provider.sha1()."""
 
1325
        filters = self.tree._content_filter_stack(
 
1326
            self.tree.relpath(osutils.safe_unicode(abspath)))
 
1327
        return internal_size_sha_file_byname(abspath, filters)[1]
 
1328
 
 
1329
    def stat_and_sha1(self, abspath):
 
1330
        """See dirstate.SHA1Provider.stat_and_sha1()."""
 
1331
        filters = self.tree._content_filter_stack(
 
1332
            self.tree.relpath(osutils.safe_unicode(abspath)))
 
1333
        file_obj = file(abspath, 'rb', 65000)
 
1334
        try:
 
1335
            statvalue = os.fstat(file_obj.fileno())
 
1336
            if filters:
 
1337
                file_obj = filtered_input_file(file_obj, filters)
 
1338
            sha1 = osutils.size_sha_file(file_obj)[1]
 
1339
        finally:
 
1340
            file_obj.close()
 
1341
        return statvalue, sha1
 
1342
 
 
1343
 
 
1344
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
 
1345
    """Dirstate working tree that supports content filtering.
 
1346
 
 
1347
    The dirstate holds the hash and size of the canonical form of the file, 
 
1348
    and most methods must return that.
 
1349
    """
 
1350
 
 
1351
    def _file_content_summary(self, path, stat_result):
 
1352
        # This is to support the somewhat obsolete path_content_summary method
 
1353
        # with content filtering: see
 
1354
        # <https://bugs.launchpad.net/bzr/+bug/415508>.
 
1355
        #
 
1356
        # If the dirstate cache is up to date and knows the hash and size,
 
1357
        # return that.
 
1358
        # Otherwise if there are no content filters, return the on-disk size
 
1359
        # and leave the hash blank.
 
1360
        # Otherwise, read and filter the on-disk file and use its size and
 
1361
        # hash.
 
1362
        #
 
1363
        # The dirstate doesn't store the size of the canonical form so we
 
1364
        # can't trust it for content-filtered trees.  We just return None.
 
1365
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
 
1366
        executable = self._is_executable_from_path_and_stat(path, stat_result)
 
1367
        return ('file', None, executable, dirstate_sha1)
 
1368
 
 
1369
 
 
1370
class WorkingTree4(DirStateWorkingTree):
 
1371
    """This is the Format 4 working tree.
 
1372
 
 
1373
    This differs from WorkingTree3 by:
 
1374
     - Having a consolidated internal dirstate, stored in a
 
1375
       randomly-accessible sorted file on disk.
 
1376
     - Not having a regular inventory attribute.  One can be synthesized
 
1377
       on demand but this is expensive and should be avoided.
 
1378
 
 
1379
    This is new in bzr 0.15.
 
1380
    """
 
1381
 
 
1382
 
 
1383
class WorkingTree5(ContentFilteringDirStateWorkingTree):
 
1384
    """This is the Format 5 working tree.
 
1385
 
 
1386
    This differs from WorkingTree4 by:
 
1387
     - Supporting content filtering.
 
1388
 
 
1389
    This is new in bzr 1.11.
 
1390
    """
 
1391
 
 
1392
 
 
1393
class WorkingTree6(ContentFilteringDirStateWorkingTree):
 
1394
    """This is the Format 6 working tree.
 
1395
 
 
1396
    This differs from WorkingTree5 by:
 
1397
     - Supporting a current view that may mask the set of files in a tree
 
1398
       impacted by most user operations.
 
1399
 
 
1400
    This is new in bzr 1.14.
 
1401
    """
 
1402
 
 
1403
    def _make_views(self):
 
1404
        return views.PathBasedViews(self)
 
1405
 
 
1406
 
 
1407
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
 
1408
 
 
1409
    missing_parent_conflicts = True
 
1410
 
 
1411
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
1412
                   accelerator_tree=None, hardlink=False):
 
1413
        """See WorkingTreeFormat.initialize().
 
1414
 
 
1415
        :param revision_id: allows creating a working tree at a different
 
1416
        revision than the branch is at.
 
1417
        :param accelerator_tree: A tree which can be used for retrieving file
 
1418
            contents more quickly than the revision tree, i.e. a workingtree.
 
1419
            The revision tree will be used for cases where accelerator_tree's
 
1420
            content is different.
 
1421
        :param hardlink: If true, hard-link files from accelerator_tree,
 
1422
            where possible.
 
1423
 
 
1424
        These trees get an initial random root id, if their repository supports
 
1425
        rich root data, TREE_ROOT otherwise.
 
1426
        """
 
1427
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1428
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1429
        transport = a_bzrdir.get_workingtree_transport(self)
 
1430
        control_files = self._open_control_files(a_bzrdir)
 
1431
        control_files.create_lock()
 
1432
        control_files.lock_write()
 
1433
        transport.put_bytes('format', self.get_format_string(),
 
1434
            mode=a_bzrdir._get_file_mode())
 
1435
        if from_branch is not None:
 
1436
            branch = from_branch
 
1437
        else:
 
1438
            branch = a_bzrdir.open_branch()
 
1439
        if revision_id is None:
 
1440
            revision_id = branch.last_revision()
 
1441
        local_path = transport.local_abspath('dirstate')
 
1442
        # write out new dirstate (must exist when we create the tree)
 
1443
        state = dirstate.DirState.initialize(local_path)
 
1444
        state.unlock()
 
1445
        del state
 
1446
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1447
                         branch,
 
1448
                         _format=self,
 
1449
                         _bzrdir=a_bzrdir,
 
1450
                         _control_files=control_files)
 
1451
        wt._new_tree()
 
1452
        wt.lock_tree_write()
 
1453
        try:
 
1454
            self._init_custom_control_files(wt)
 
1455
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1456
                if branch.repository.supports_rich_root():
 
1457
                    wt._set_root_id(generate_ids.gen_root_id())
 
1458
                else:
 
1459
                    wt._set_root_id(ROOT_ID)
 
1460
                wt.flush()
 
1461
            basis = None
 
1462
            # frequently, we will get here due to branching.  The accelerator
 
1463
            # tree will be the tree from the branch, so the desired basis
 
1464
            # tree will often be a parent of the accelerator tree.
 
1465
            if accelerator_tree is not None:
 
1466
                try:
 
1467
                    basis = accelerator_tree.revision_tree(revision_id)
 
1468
                except errors.NoSuchRevision:
 
1469
                    pass
 
1470
            if basis is None:
 
1471
                basis = branch.repository.revision_tree(revision_id)
 
1472
            if revision_id == _mod_revision.NULL_REVISION:
 
1473
                parents_list = []
 
1474
            else:
 
1475
                parents_list = [(revision_id, basis)]
 
1476
            basis.lock_read()
 
1477
            try:
 
1478
                wt.set_parent_trees(parents_list, allow_leftmost_as_ghost=True)
 
1479
                wt.flush()
 
1480
                # if the basis has a root id we have to use that; otherwise we
 
1481
                # use a new random one
 
1482
                basis_root_id = basis.get_root_id()
 
1483
                if basis_root_id is not None:
 
1484
                    wt._set_root_id(basis_root_id)
 
1485
                    wt.flush()
 
1486
                if wt.supports_content_filtering():
 
1487
                    # The original tree may not have the same content filters
 
1488
                    # applied so we can't safely build the inventory delta from
 
1489
                    # the source tree.
 
1490
                    delta_from_tree = False
 
1491
                else:
 
1492
                    delta_from_tree = True
 
1493
                # delta_from_tree is safe even for DirStateRevisionTrees,
 
1494
                # because wt4.apply_inventory_delta does not mutate the input
 
1495
                # inventory entries.
 
1496
                transform.build_tree(basis, wt, accelerator_tree,
 
1497
                                     hardlink=hardlink,
 
1498
                                     delta_from_tree=delta_from_tree)
 
1499
            finally:
 
1500
                basis.unlock()
 
1501
        finally:
 
1502
            control_files.unlock()
 
1503
            wt.unlock()
 
1504
        return wt
 
1505
 
 
1506
    def _init_custom_control_files(self, wt):
 
1507
        """Subclasses with custom control files should override this method.
 
1508
 
 
1509
        The working tree and control files are locked for writing when this
 
1510
        method is called.
 
1511
 
 
1512
        :param wt: the WorkingTree object
 
1513
        """
 
1514
 
 
1515
    def _open(self, a_bzrdir, control_files):
 
1516
        """Open the tree itself.
 
1517
 
 
1518
        :param a_bzrdir: the dir for the tree.
 
1519
        :param control_files: the control files for the tree.
 
1520
        """
 
1521
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1522
                           branch=a_bzrdir.open_branch(),
 
1523
                           _format=self,
 
1524
                           _bzrdir=a_bzrdir,
 
1525
                           _control_files=control_files)
 
1526
 
 
1527
    def __get_matchingbzrdir(self):
 
1528
        return self._get_matchingbzrdir()
 
1529
 
 
1530
    def _get_matchingbzrdir(self):
 
1531
        """Overrideable method to get a bzrdir for testing."""
 
1532
        # please test against something that will let us do tree references
 
1533
        return bzrdir.format_registry.make_bzrdir(
 
1534
            'dirstate-with-subtree')
 
1535
 
 
1536
    _matchingbzrdir = property(__get_matchingbzrdir)
 
1537
 
 
1538
 
 
1539
class WorkingTreeFormat4(DirStateWorkingTreeFormat):
 
1540
    """The first consolidated dirstate working tree format.
 
1541
 
 
1542
    This format:
 
1543
        - exists within a metadir controlling .bzr
 
1544
        - includes an explicit version marker for the workingtree control
 
1545
          files, separate from the BzrDir format
 
1546
        - modifies the hash cache format
 
1547
        - is new in bzr 0.15
 
1548
        - uses a LockDir to guard access to it.
 
1549
    """
 
1550
 
 
1551
    upgrade_recommended = False
 
1552
 
 
1553
    _tree_class = WorkingTree4
 
1554
 
 
1555
    def get_format_string(self):
 
1556
        """See WorkingTreeFormat.get_format_string()."""
 
1557
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1558
 
 
1559
    def get_format_description(self):
 
1560
        """See WorkingTreeFormat.get_format_description()."""
 
1561
        return "Working tree format 4"
 
1562
 
 
1563
 
 
1564
class WorkingTreeFormat5(DirStateWorkingTreeFormat):
 
1565
    """WorkingTree format supporting content filtering.
 
1566
    """
 
1567
 
 
1568
    upgrade_recommended = False
 
1569
 
 
1570
    _tree_class = WorkingTree5
 
1571
 
 
1572
    def get_format_string(self):
 
1573
        """See WorkingTreeFormat.get_format_string()."""
 
1574
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
 
1575
 
 
1576
    def get_format_description(self):
 
1577
        """See WorkingTreeFormat.get_format_description()."""
 
1578
        return "Working tree format 5"
 
1579
 
 
1580
    def supports_content_filtering(self):
 
1581
        return True
 
1582
 
 
1583
 
 
1584
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
 
1585
    """WorkingTree format supporting views.
 
1586
    """
 
1587
 
 
1588
    upgrade_recommended = False
 
1589
 
 
1590
    _tree_class = WorkingTree6
 
1591
 
 
1592
    def get_format_string(self):
 
1593
        """See WorkingTreeFormat.get_format_string()."""
 
1594
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
 
1595
 
 
1596
    def get_format_description(self):
 
1597
        """See WorkingTreeFormat.get_format_description()."""
 
1598
        return "Working tree format 6"
 
1599
 
 
1600
    def _init_custom_control_files(self, wt):
 
1601
        """Subclasses with custom control files should override this method."""
 
1602
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
 
1603
 
 
1604
    def supports_content_filtering(self):
 
1605
        return True
 
1606
 
 
1607
    def supports_views(self):
 
1608
        return True
 
1609
 
 
1610
 
 
1611
class DirStateRevisionTree(Tree):
 
1612
    """A revision tree pulling the inventory from a dirstate.
 
1613
    
 
1614
    Note that this is one of the historical (ie revision) trees cached in the
 
1615
    dirstate for easy access, not the workingtree.
 
1616
    """
 
1617
 
 
1618
    def __init__(self, dirstate, revision_id, repository):
 
1619
        self._dirstate = dirstate
 
1620
        self._revision_id = revision_id
 
1621
        self._repository = repository
 
1622
        self._inventory = None
 
1623
        self._locked = 0
 
1624
        self._dirstate_locked = False
 
1625
        self._repo_supports_tree_reference = getattr(
 
1626
            repository._format, "supports_tree_reference",
 
1627
            False)
 
1628
 
 
1629
    def __repr__(self):
 
1630
        return "<%s of %s in %s>" % \
 
1631
            (self.__class__.__name__, self._revision_id, self._dirstate)
 
1632
 
 
1633
    def annotate_iter(self, file_id,
 
1634
                      default_revision=_mod_revision.CURRENT_REVISION):
 
1635
        """See Tree.annotate_iter"""
 
1636
        text_key = (file_id, self.inventory[file_id].revision)
 
1637
        annotations = self._repository.texts.annotate(text_key)
 
1638
        return [(key[-1], line) for (key, line) in annotations]
 
1639
 
 
1640
    def _get_ancestors(self, default_revision):
 
1641
        return set(self._repository.get_ancestry(self._revision_id,
 
1642
                                                 topo_sorted=False))
 
1643
    def _comparison_data(self, entry, path):
 
1644
        """See Tree._comparison_data."""
 
1645
        if entry is None:
 
1646
            return None, False, None
 
1647
        # trust the entry as RevisionTree does, but this may not be
 
1648
        # sensible: the entry might not have come from us?
 
1649
        return entry.kind, entry.executable, None
 
1650
 
 
1651
    def _file_size(self, entry, stat_value):
 
1652
        return entry.text_size
 
1653
 
 
1654
    def filter_unversioned_files(self, paths):
 
1655
        """Filter out paths that are not versioned.
 
1656
 
 
1657
        :return: set of paths.
 
1658
        """
 
1659
        pred = self.has_filename
 
1660
        return set((p for p in paths if not pred(p)))
 
1661
 
 
1662
    def get_root_id(self):
 
1663
        return self.path2id('')
 
1664
 
 
1665
    def id2path(self, file_id):
 
1666
        "Convert a file-id to a path."
 
1667
        entry = self._get_entry(file_id=file_id)
 
1668
        if entry == (None, None):
 
1669
            raise errors.NoSuchId(tree=self, file_id=file_id)
 
1670
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
1671
        return path_utf8.decode('utf8')
 
1672
 
 
1673
    def iter_references(self):
 
1674
        if not self._repo_supports_tree_reference:
 
1675
            # When the repo doesn't support references, we will have nothing to
 
1676
            # return
 
1677
            return iter([])
 
1678
        # Otherwise, fall back to the default implementation
 
1679
        return super(DirStateRevisionTree, self).iter_references()
 
1680
 
 
1681
    def _get_parent_index(self):
 
1682
        """Return the index in the dirstate referenced by this tree."""
 
1683
        return self._dirstate.get_parent_ids().index(self._revision_id) + 1
 
1684
 
 
1685
    def _get_entry(self, file_id=None, path=None):
 
1686
        """Get the dirstate row for file_id or path.
 
1687
 
 
1688
        If either file_id or path is supplied, it is used as the key to lookup.
 
1689
        If both are supplied, the fastest lookup is used, and an error is
 
1690
        raised if they do not both point at the same row.
 
1691
 
 
1692
        :param file_id: An optional unicode file_id to be looked up.
 
1693
        :param path: An optional unicode path to be looked up.
 
1694
        :return: The dirstate row tuple for path/file_id, or (None, None)
 
1695
        """
 
1696
        if file_id is None and path is None:
 
1697
            raise errors.BzrError('must supply file_id or path')
 
1698
        if path is not None:
 
1699
            path = path.encode('utf8')
 
1700
        parent_index = self._get_parent_index()
 
1701
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id, path_utf8=path)
 
1702
 
 
1703
    def _generate_inventory(self):
 
1704
        """Create and set self.inventory from the dirstate object.
 
1705
 
 
1706
        (So this is only called the first time the inventory is requested for
 
1707
        this tree; it then remains in memory until it's out of date.)
 
1708
 
 
1709
        This is relatively expensive: we have to walk the entire dirstate.
 
1710
        """
 
1711
        if not self._locked:
 
1712
            raise AssertionError(
 
1713
                'cannot generate inventory of an unlocked '
 
1714
                'dirstate revision tree')
 
1715
        # separate call for profiling - makes it clear where the costs are.
 
1716
        self._dirstate._read_dirblocks_if_needed()
 
1717
        if self._revision_id not in self._dirstate.get_parent_ids():
 
1718
            raise AssertionError(
 
1719
                'parent %s has disappeared from %s' % (
 
1720
                self._revision_id, self._dirstate.get_parent_ids()))
 
1721
        parent_index = self._dirstate.get_parent_ids().index(self._revision_id) + 1
 
1722
        # This is identical now to the WorkingTree _generate_inventory except
 
1723
        # for the tree index use.
 
1724
        root_key, current_entry = self._dirstate._get_entry(parent_index, path_utf8='')
 
1725
        current_id = root_key[2]
 
1726
        if current_entry[parent_index][0] != 'd':
 
1727
            raise AssertionError()
 
1728
        inv = Inventory(root_id=current_id, revision_id=self._revision_id)
 
1729
        inv.root.revision = current_entry[parent_index][4]
 
1730
        # Turn some things into local variables
 
1731
        minikind_to_kind = dirstate.DirState._minikind_to_kind
 
1732
        factory = entry_factory
 
1733
        utf8_decode = cache_utf8._utf8_decode
 
1734
        inv_byid = inv._byid
 
1735
        # we could do this straight out of the dirstate; it might be fast
 
1736
        # and should be profiled - RBC 20070216
 
1737
        parent_ies = {'' : inv.root}
 
1738
        for block in self._dirstate._dirblocks[1:]: #skip root
 
1739
            dirname = block[0]
 
1740
            try:
 
1741
                parent_ie = parent_ies[dirname]
 
1742
            except KeyError:
 
1743
                # all the paths in this block are not versioned in this tree
 
1744
                continue
 
1745
            for key, entry in block[1]:
 
1746
                minikind, fingerprint, size, executable, revid = entry[parent_index]
 
1747
                if minikind in ('a', 'r'): # absent, relocated
 
1748
                    # not this tree
 
1749
                    continue
 
1750
                name = key[1]
 
1751
                name_unicode = utf8_decode(name)[0]
 
1752
                file_id = key[2]
 
1753
                kind = minikind_to_kind[minikind]
 
1754
                inv_entry = factory[kind](file_id, name_unicode,
 
1755
                                          parent_ie.file_id)
 
1756
                inv_entry.revision = revid
 
1757
                if kind == 'file':
 
1758
                    inv_entry.executable = executable
 
1759
                    inv_entry.text_size = size
 
1760
                    inv_entry.text_sha1 = fingerprint
 
1761
                elif kind == 'directory':
 
1762
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
 
1763
                elif kind == 'symlink':
 
1764
                    inv_entry.symlink_target = utf8_decode(fingerprint)[0]
 
1765
                elif kind == 'tree-reference':
 
1766
                    inv_entry.reference_revision = fingerprint or None
 
1767
                else:
 
1768
                    raise AssertionError("cannot convert entry %r into an InventoryEntry"
 
1769
                            % entry)
 
1770
                # These checks cost us around 40ms on a 55k entry tree
 
1771
                if file_id in inv_byid:
 
1772
                    raise AssertionError('file_id %s already in'
 
1773
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
 
1774
                if name_unicode in parent_ie.children:
 
1775
                    raise AssertionError('name %r already in parent'
 
1776
                        % (name_unicode,))
 
1777
                inv_byid[file_id] = inv_entry
 
1778
                parent_ie.children[name_unicode] = inv_entry
 
1779
        self._inventory = inv
 
1780
 
 
1781
    def get_file_mtime(self, file_id, path=None):
 
1782
        """Return the modification time for this record.
 
1783
 
 
1784
        We return the timestamp of the last-changed revision.
 
1785
        """
 
1786
        # Make sure the file exists
 
1787
        entry = self._get_entry(file_id, path=path)
 
1788
        if entry == (None, None): # do we raise?
 
1789
            return None
 
1790
        parent_index = self._get_parent_index()
 
1791
        last_changed_revision = entry[1][parent_index][4]
 
1792
        try:
 
1793
            rev = self._repository.get_revision(last_changed_revision)
 
1794
        except errors.NoSuchRevision:
 
1795
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
 
1796
        return rev.timestamp
 
1797
 
 
1798
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
1799
        entry = self._get_entry(file_id=file_id, path=path)
 
1800
        parent_index = self._get_parent_index()
 
1801
        parent_details = entry[1][parent_index]
 
1802
        if parent_details[0] == 'f':
 
1803
            return parent_details[1]
 
1804
        return None
 
1805
 
 
1806
    def get_file(self, file_id, path=None):
 
1807
        return StringIO(self.get_file_text(file_id))
 
1808
 
 
1809
    def get_file_size(self, file_id):
 
1810
        """See Tree.get_file_size"""
 
1811
        return self.inventory[file_id].text_size
 
1812
 
 
1813
    def get_file_text(self, file_id, path=None):
 
1814
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
 
1815
        return ''.join(content)
 
1816
 
 
1817
    def get_reference_revision(self, file_id, path=None):
 
1818
        return self.inventory[file_id].reference_revision
 
1819
 
 
1820
    def iter_files_bytes(self, desired_files):
 
1821
        """See Tree.iter_files_bytes.
 
1822
 
 
1823
        This version is implemented on top of Repository.iter_files_bytes"""
 
1824
        parent_index = self._get_parent_index()
 
1825
        repo_desired_files = []
 
1826
        for file_id, identifier in desired_files:
 
1827
            entry = self._get_entry(file_id)
 
1828
            if entry == (None, None):
 
1829
                raise errors.NoSuchId(self, file_id)
 
1830
            repo_desired_files.append((file_id, entry[1][parent_index][4],
 
1831
                                       identifier))
 
1832
        return self._repository.iter_files_bytes(repo_desired_files)
 
1833
 
 
1834
    def get_symlink_target(self, file_id):
 
1835
        entry = self._get_entry(file_id=file_id)
 
1836
        parent_index = self._get_parent_index()
 
1837
        if entry[1][parent_index][0] != 'l':
 
1838
            return None
 
1839
        else:
 
1840
            target = entry[1][parent_index][1]
 
1841
            target = target.decode('utf8')
 
1842
            return target
 
1843
 
 
1844
    def get_revision_id(self):
 
1845
        """Return the revision id for this tree."""
 
1846
        return self._revision_id
 
1847
 
 
1848
    def _get_inventory(self):
 
1849
        if self._inventory is not None:
 
1850
            return self._inventory
 
1851
        self._must_be_locked()
 
1852
        self._generate_inventory()
 
1853
        return self._inventory
 
1854
 
 
1855
    inventory = property(_get_inventory,
 
1856
                         doc="Inventory of this Tree")
 
1857
 
 
1858
    def get_parent_ids(self):
 
1859
        """The parents of a tree in the dirstate are not cached."""
 
1860
        return self._repository.get_revision(self._revision_id).parent_ids
 
1861
 
 
1862
    def has_filename(self, filename):
 
1863
        return bool(self.path2id(filename))
 
1864
 
 
1865
    def kind(self, file_id):
 
1866
        entry = self._get_entry(file_id=file_id)[1]
 
1867
        if entry is None:
 
1868
            raise errors.NoSuchId(tree=self, file_id=file_id)
 
1869
        parent_index = self._get_parent_index()
 
1870
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 
1871
 
 
1872
    def stored_kind(self, file_id):
 
1873
        """See Tree.stored_kind"""
 
1874
        return self.kind(file_id)
 
1875
 
 
1876
    def path_content_summary(self, path):
 
1877
        """See Tree.path_content_summary."""
 
1878
        id = self.inventory.path2id(path)
 
1879
        if id is None:
 
1880
            return ('missing', None, None, None)
 
1881
        entry = self._inventory[id]
 
1882
        kind = entry.kind
 
1883
        if kind == 'file':
 
1884
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
 
1885
        elif kind == 'symlink':
 
1886
            return (kind, None, None, entry.symlink_target)
 
1887
        else:
 
1888
            return (kind, None, None, None)
 
1889
 
 
1890
    def is_executable(self, file_id, path=None):
 
1891
        ie = self.inventory[file_id]
 
1892
        if ie.kind != "file":
 
1893
            return False
 
1894
        return ie.executable
 
1895
 
 
1896
    def is_locked(self):
 
1897
        return self._locked
 
1898
 
 
1899
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1900
        # We use a standard implementation, because DirStateRevisionTree is
 
1901
        # dealing with one of the parents of the current state
 
1902
        inv = self._get_inventory()
 
1903
        if from_dir is None:
 
1904
            from_dir_id = None
 
1905
        else:
 
1906
            from_dir_id = inv.path2id(from_dir)
 
1907
            if from_dir_id is None:
 
1908
                # Directory not versioned
 
1909
                return
 
1910
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
 
1911
        if inv.root is not None and not include_root and from_dir is None:
 
1912
            entries.next()
 
1913
        for path, entry in entries:
 
1914
            yield path, 'V', entry.kind, entry.file_id, entry
 
1915
 
 
1916
    def lock_read(self):
 
1917
        """Lock the tree for a set of operations.
 
1918
 
 
1919
        :return: A bzrlib.lock.LogicalLockResult.
 
1920
        """
 
1921
        if not self._locked:
 
1922
            self._repository.lock_read()
 
1923
            if self._dirstate._lock_token is None:
 
1924
                self._dirstate.lock_read()
 
1925
                self._dirstate_locked = True
 
1926
        self._locked += 1
 
1927
        return LogicalLockResult(self.unlock)
 
1928
 
 
1929
    def _must_be_locked(self):
 
1930
        if not self._locked:
 
1931
            raise errors.ObjectNotLocked(self)
 
1932
 
 
1933
    @needs_read_lock
 
1934
    def path2id(self, path):
 
1935
        """Return the id for path in this tree."""
 
1936
        # lookup by path: faster than splitting and walking the ivnentory.
 
1937
        entry = self._get_entry(path=path)
 
1938
        if entry == (None, None):
 
1939
            return None
 
1940
        return entry[0][2]
 
1941
 
 
1942
    def unlock(self):
 
1943
        """Unlock, freeing any cache memory used during the lock."""
 
1944
        # outside of a lock, the inventory is suspect: release it.
 
1945
        self._locked -=1
 
1946
        if not self._locked:
 
1947
            self._inventory = None
 
1948
            self._locked = 0
 
1949
            if self._dirstate_locked:
 
1950
                self._dirstate.unlock()
 
1951
                self._dirstate_locked = False
 
1952
            self._repository.unlock()
 
1953
 
 
1954
    @needs_read_lock
 
1955
    def supports_tree_reference(self):
 
1956
        return self._repo_supports_tree_reference
 
1957
 
 
1958
    def walkdirs(self, prefix=""):
 
1959
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
 
1960
        # implementation based on an inventory.
 
1961
        # This should be cleaned up to use the much faster Dirstate code
 
1962
        # So for now, we just build up the parent inventory, and extract
 
1963
        # it the same way RevisionTree does.
 
1964
        _directory = 'directory'
 
1965
        inv = self._get_inventory()
 
1966
        top_id = inv.path2id(prefix)
 
1967
        if top_id is None:
 
1968
            pending = []
 
1969
        else:
 
1970
            pending = [(prefix, top_id)]
 
1971
        while pending:
 
1972
            dirblock = []
 
1973
            relpath, file_id = pending.pop()
 
1974
            # 0 - relpath, 1- file-id
 
1975
            if relpath:
 
1976
                relroot = relpath + '/'
 
1977
            else:
 
1978
                relroot = ""
 
1979
            # FIXME: stash the node in pending
 
1980
            entry = inv[file_id]
 
1981
            for name, child in entry.sorted_children():
 
1982
                toppath = relroot + name
 
1983
                dirblock.append((toppath, name, child.kind, None,
 
1984
                    child.file_id, child.kind
 
1985
                    ))
 
1986
            yield (relpath, entry.file_id), dirblock
 
1987
            # push the user specified dirs from dirblock
 
1988
            for dir in reversed(dirblock):
 
1989
                if dir[2] == _directory:
 
1990
                    pending.append((dir[0], dir[4]))
 
1991
 
 
1992
 
 
1993
class InterDirStateTree(InterTree):
 
1994
    """Fast path optimiser for changes_from with dirstate trees.
 
1995
 
 
1996
    This is used only when both trees are in the dirstate working file, and
 
1997
    the source is any parent within the dirstate, and the destination is
 
1998
    the current working tree of the same dirstate.
 
1999
    """
 
2000
    # this could be generalized to allow comparisons between any trees in the
 
2001
    # dirstate, and possibly between trees stored in different dirstates.
 
2002
 
 
2003
    def __init__(self, source, target):
 
2004
        super(InterDirStateTree, self).__init__(source, target)
 
2005
        if not InterDirStateTree.is_compatible(source, target):
 
2006
            raise Exception, "invalid source %r and target %r" % (source, target)
 
2007
 
 
2008
    @staticmethod
 
2009
    def make_source_parent_tree(source, target):
 
2010
        """Change the source tree into a parent of the target."""
 
2011
        revid = source.commit('record tree')
 
2012
        target.branch.repository.fetch(source.branch.repository, revid)
 
2013
        target.set_parent_ids([revid])
 
2014
        return target.basis_tree(), target
 
2015
 
 
2016
    @classmethod
 
2017
    def make_source_parent_tree_python_dirstate(klass, test_case, source, target):
 
2018
        result = klass.make_source_parent_tree(source, target)
 
2019
        result[1]._iter_changes = dirstate.ProcessEntryPython
 
2020
        return result
 
2021
 
 
2022
    @classmethod
 
2023
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
 
2024
                                                  target):
 
2025
        from bzrlib.tests.test__dirstate_helpers import \
 
2026
            compiled_dirstate_helpers_feature
 
2027
        test_case.requireFeature(compiled_dirstate_helpers_feature)
 
2028
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
2029
        result = klass.make_source_parent_tree(source, target)
 
2030
        result[1]._iter_changes = ProcessEntryC
 
2031
        return result
 
2032
 
 
2033
    _matching_from_tree_format = WorkingTreeFormat4()
 
2034
    _matching_to_tree_format = WorkingTreeFormat4()
 
2035
 
 
2036
    @classmethod
 
2037
    def _test_mutable_trees_to_test_trees(klass, test_case, source, target):
 
2038
        # This method shouldn't be called, because we have python and C
 
2039
        # specific flavours.
 
2040
        raise NotImplementedError
 
2041
 
 
2042
    def iter_changes(self, include_unchanged=False,
 
2043
                      specific_files=None, pb=None, extra_trees=[],
 
2044
                      require_versioned=True, want_unversioned=False):
 
2045
        """Return the changes from source to target.
 
2046
 
 
2047
        :return: An iterator that yields tuples. See InterTree.iter_changes
 
2048
            for details.
 
2049
        :param specific_files: An optional list of file paths to restrict the
 
2050
            comparison to. When mapping filenames to ids, all matches in all
 
2051
            trees (including optional extra_trees) are used, and all children of
 
2052
            matched directories are included.
 
2053
        :param include_unchanged: An optional boolean requesting the inclusion of
 
2054
            unchanged entries in the result.
 
2055
        :param extra_trees: An optional list of additional trees to use when
 
2056
            mapping the contents of specific_files (paths) to file_ids.
 
2057
        :param require_versioned: If True, all files in specific_files must be
 
2058
            versioned in one of source, target, extra_trees or
 
2059
            PathsNotVersionedError is raised.
 
2060
        :param want_unversioned: Should unversioned files be returned in the
 
2061
            output. An unversioned file is defined as one with (False, False)
 
2062
            for the versioned pair.
 
2063
        """
 
2064
        # TODO: handle extra trees in the dirstate.
 
2065
        if (extra_trees or specific_files == []):
 
2066
            # we can't fast-path these cases (yet)
 
2067
            return super(InterDirStateTree, self).iter_changes(
 
2068
                include_unchanged, specific_files, pb, extra_trees,
 
2069
                require_versioned, want_unversioned=want_unversioned)
 
2070
        parent_ids = self.target.get_parent_ids()
 
2071
        if not (self.source._revision_id in parent_ids
 
2072
                or self.source._revision_id == _mod_revision.NULL_REVISION):
 
2073
            raise AssertionError(
 
2074
                "revision {%s} is not stored in {%s}, but %s "
 
2075
                "can only be used for trees stored in the dirstate"
 
2076
                % (self.source._revision_id, self.target, self.iter_changes))
 
2077
        target_index = 0
 
2078
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
2079
            source_index = None
 
2080
            indices = (target_index,)
 
2081
        else:
 
2082
            if not (self.source._revision_id in parent_ids):
 
2083
                raise AssertionError(
 
2084
                    "Failure: source._revision_id: %s not in target.parent_ids(%s)" % (
 
2085
                    self.source._revision_id, parent_ids))
 
2086
            source_index = 1 + parent_ids.index(self.source._revision_id)
 
2087
            indices = (source_index, target_index)
 
2088
        # -- make all specific_files utf8 --
 
2089
        if specific_files:
 
2090
            specific_files_utf8 = set()
 
2091
            for path in specific_files:
 
2092
                # Note, if there are many specific files, using cache_utf8
 
2093
                # would be good here.
 
2094
                specific_files_utf8.add(path.encode('utf8'))
 
2095
            specific_files = specific_files_utf8
 
2096
        else:
 
2097
            specific_files = set([''])
 
2098
        # -- specific_files is now a utf8 path set --
 
2099
 
 
2100
        # -- get the state object and prepare it.
 
2101
        state = self.target.current_dirstate()
 
2102
        state._read_dirblocks_if_needed()
 
2103
        if require_versioned:
 
2104
            # -- check all supplied paths are versioned in a search tree. --
 
2105
            not_versioned = []
 
2106
            for path in specific_files:
 
2107
                path_entries = state._entries_for_path(path)
 
2108
                if not path_entries:
 
2109
                    # this specified path is not present at all: error
 
2110
                    not_versioned.append(path)
 
2111
                    continue
 
2112
                found_versioned = False
 
2113
                # for each id at this path
 
2114
                for entry in path_entries:
 
2115
                    # for each tree.
 
2116
                    for index in indices:
 
2117
                        if entry[1][index][0] != 'a': # absent
 
2118
                            found_versioned = True
 
2119
                            # all good: found a versioned cell
 
2120
                            break
 
2121
                if not found_versioned:
 
2122
                    # none of the indexes was not 'absent' at all ids for this
 
2123
                    # path.
 
2124
                    not_versioned.append(path)
 
2125
            if len(not_versioned) > 0:
 
2126
                raise errors.PathsNotVersionedError(not_versioned)
 
2127
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
 
2128
        search_specific_files = osutils.minimum_path_selection(specific_files)
 
2129
 
 
2130
        use_filesystem_for_exec = (sys.platform != 'win32')
 
2131
        iter_changes = self.target._iter_changes(include_unchanged,
 
2132
            use_filesystem_for_exec, search_specific_files, state,
 
2133
            source_index, target_index, want_unversioned, self.target)
 
2134
        return iter_changes.iter_changes()
 
2135
 
 
2136
    @staticmethod
 
2137
    def is_compatible(source, target):
 
2138
        # the target must be a dirstate working tree
 
2139
        if not isinstance(target, DirStateWorkingTree):
 
2140
            return False
 
2141
        # the source must be a revtree or dirstate rev tree.
 
2142
        if not isinstance(source,
 
2143
            (revisiontree.RevisionTree, DirStateRevisionTree)):
 
2144
            return False
 
2145
        # the source revid must be in the target dirstate
 
2146
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
2147
            source._revision_id in target.get_parent_ids()):
 
2148
            # TODO: what about ghosts? it may well need to
 
2149
            # check for them explicitly.
 
2150
            return False
 
2151
        return True
 
2152
 
 
2153
InterTree.register_optimiser(InterDirStateTree)
 
2154
 
 
2155
 
 
2156
class Converter3to4(object):
 
2157
    """Perform an in-place upgrade of format 3 to format 4 trees."""
 
2158
 
 
2159
    def __init__(self):
 
2160
        self.target_format = WorkingTreeFormat4()
 
2161
 
 
2162
    def convert(self, tree):
 
2163
        # lock the control files not the tree, so that we dont get tree
 
2164
        # on-unlock behaviours, and so that noone else diddles with the
 
2165
        # tree during upgrade.
 
2166
        tree._control_files.lock_write()
 
2167
        try:
 
2168
            tree.read_working_inventory()
 
2169
            self.create_dirstate_data(tree)
 
2170
            self.update_format(tree)
 
2171
            self.remove_xml_files(tree)
 
2172
        finally:
 
2173
            tree._control_files.unlock()
 
2174
 
 
2175
    def create_dirstate_data(self, tree):
 
2176
        """Create the dirstate based data for tree."""
 
2177
        local_path = tree.bzrdir.get_workingtree_transport(None
 
2178
            ).local_abspath('dirstate')
 
2179
        state = dirstate.DirState.from_tree(tree, local_path)
 
2180
        state.save()
 
2181
        state.unlock()
 
2182
 
 
2183
    def remove_xml_files(self, tree):
 
2184
        """Remove the oldformat 3 data."""
 
2185
        transport = tree.bzrdir.get_workingtree_transport(None)
 
2186
        for path in ['basis-inventory-cache', 'inventory', 'last-revision',
 
2187
            'pending-merges', 'stat-cache']:
 
2188
            try:
 
2189
                transport.delete(path)
 
2190
            except errors.NoSuchFile:
 
2191
                # some files are optional - just deal.
 
2192
                pass
 
2193
 
 
2194
    def update_format(self, tree):
 
2195
        """Change the format marker."""
 
2196
        tree._transport.put_bytes('format',
 
2197
            self.target_format.get_format_string(),
 
2198
            mode=tree.bzrdir._get_file_mode())
 
2199
 
 
2200
 
 
2201
class Converter4to5(object):
 
2202
    """Perform an in-place upgrade of format 4 to format 5 trees."""
 
2203
 
 
2204
    def __init__(self):
 
2205
        self.target_format = WorkingTreeFormat5()
 
2206
 
 
2207
    def convert(self, tree):
 
2208
        # lock the control files not the tree, so that we don't get tree
 
2209
        # on-unlock behaviours, and so that no-one else diddles with the
 
2210
        # tree during upgrade.
 
2211
        tree._control_files.lock_write()
 
2212
        try:
 
2213
            self.update_format(tree)
 
2214
        finally:
 
2215
            tree._control_files.unlock()
 
2216
 
 
2217
    def update_format(self, tree):
 
2218
        """Change the format marker."""
 
2219
        tree._transport.put_bytes('format',
 
2220
            self.target_format.get_format_string(),
 
2221
            mode=tree.bzrdir._get_file_mode())
 
2222
 
 
2223
 
 
2224
class Converter4or5to6(object):
 
2225
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
 
2226
 
 
2227
    def __init__(self):
 
2228
        self.target_format = WorkingTreeFormat6()
 
2229
 
 
2230
    def convert(self, tree):
 
2231
        # lock the control files not the tree, so that we don't get tree
 
2232
        # on-unlock behaviours, and so that no-one else diddles with the
 
2233
        # tree during upgrade.
 
2234
        tree._control_files.lock_write()
 
2235
        try:
 
2236
            self.init_custom_control_files(tree)
 
2237
            self.update_format(tree)
 
2238
        finally:
 
2239
            tree._control_files.unlock()
 
2240
 
 
2241
    def init_custom_control_files(self, tree):
 
2242
        """Initialize custom control files."""
 
2243
        tree._transport.put_bytes('views', '',
 
2244
            mode=tree.bzrdir._get_file_mode())
 
2245
 
 
2246
    def update_format(self, tree):
 
2247
        """Change the format marker."""
 
2248
        tree._transport.put_bytes('format',
 
2249
            self.target_format.get_format_string(),
 
2250
            mode=tree.bzrdir._get_file_mode())