/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/bzr/workingtree_4.py

  • Committer: Jelmer Vernooij
  • Date: 2019-11-03 12:38:45 UTC
  • mto: This revision was merged to the branch mainline in revision 7413.
  • Revision ID: jelmer@jelmer.uk-20191103123845-5726o8n89u0i5bjw
Fix tests.

Show diffs side-by-side

added added

removed removed

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