← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/memorytree.py

(jelmer) Support upgrading between the 2a and development-colo formats.
 (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/memorytree.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""MemoryTree object.
18
18
 
20
20
"""
21
21
 
22
22
 
23
 
from copy import deepcopy
 
23
import os
24
24
 
25
25
from bzrlib import (
26
26
    errors,
27
27
    mutabletree,
28
28
    revision as _mod_revision,
29
29
    )
30
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
30
from bzrlib.decorators import needs_read_lock
 
31
from bzrlib.inventory import Inventory
31
32
from bzrlib.osutils import sha_file
32
33
from bzrlib.mutabletree import needs_tree_write_lock
33
34
from bzrlib.transport.memory import MemoryTransport
34
35
 
35
36
 
36
 
class MemoryTree(mutabletree.MutableTree):
 
37
class MemoryTree(mutabletree.MutableInventoryTree):
37
38
    """A MemoryTree is a specialisation of MutableTree.
38
 
    
 
39
 
39
40
    It maintains nearly no state outside of read_lock and write_lock
40
41
    transactions. (it keeps a reference to the branch, and its last-revision
41
42
    only).
49
50
        self._locks = 0
50
51
        self._lock_mode = None
51
52
 
 
53
    def is_control_filename(self, filename):
 
54
        # Memory tree doesn't have any control filenames
 
55
        return False
 
56
 
52
57
    @needs_tree_write_lock
53
58
    def _add(self, files, ids, kinds):
54
59
        """See MutableTree._add."""
68
73
    def create_on_branch(branch):
69
74
        """Create a MemoryTree for branch, using the last-revision of branch."""
70
75
        revision_id = _mod_revision.ensure_null(branch.last_revision())
71
 
        if _mod_revision.is_null(revision_id):
72
 
            revision_id = None
73
76
        return MemoryTree(branch, revision_id)
74
77
 
75
78
    def _gather_kinds(self, files, kinds):
76
79
        """See MutableTree._gather_kinds.
77
 
        
 
80
 
78
81
        This implementation does not care about the file kind of
79
82
        missing files, so is a no-op.
80
83
        """
101
104
            return None, False, None
102
105
        return entry.kind, entry.executable, None
103
106
 
 
107
    @needs_tree_write_lock
 
108
    def rename_one(self, from_rel, to_rel):
 
109
        file_id = self.path2id(from_rel)
 
110
        to_dir, to_tail = os.path.split(to_rel)
 
111
        to_parent_id = self.path2id(to_dir)
 
112
        self._file_transport.move(from_rel, to_rel)
 
113
        self._inventory.rename(file_id, to_parent_id, to_tail)
 
114
 
104
115
    def path_content_summary(self, path):
105
116
        """See Tree.path_content_summary."""
106
117
        id = self.path2id(path)
204
215
 
205
216
    def _populate_from_branch(self):
206
217
        """Populate the in-tree state from the branch."""
207
 
        self._basis_tree = self.branch.repository.revision_tree(
208
 
            self._branch_revision_id)
209
 
        if self._branch_revision_id is None:
 
218
        self._set_basis()
 
219
        if self._branch_revision_id == _mod_revision.NULL_REVISION:
210
220
            self._parent_ids = []
211
221
        else:
212
222
            self._parent_ids = [self._branch_revision_id]
213
 
        self._inventory = deepcopy(self._basis_tree._inventory)
 
223
        self._inventory = Inventory(None, self._basis_tree.get_revision_id())
214
224
        self._file_transport = MemoryTransport()
215
225
        # TODO copy the revision trees content, or do it lazy, or something.
216
 
        inventory_entries = self._inventory.iter_entries()
 
226
        inventory_entries = self._basis_tree.iter_entries_by_dir()
217
227
        for path, entry in inventory_entries:
 
228
            self._inventory.add(entry.copy())
218
229
            if path == '':
219
230
                continue
220
231
            if entry.kind == 'directory':
272
283
            _mod_revision.check_not_reserved_id(revision_id)
273
284
        if len(revision_ids) == 0:
274
285
            self._parent_ids = []
275
 
            self._basis_tree = self.branch.repository.revision_tree(None)
 
286
            self._branch_revision_id = _mod_revision.NULL_REVISION
276
287
        else:
277
288
            self._parent_ids = revision_ids
278
 
            self._basis_tree = self.branch.repository.revision_tree(
279
 
                                    revision_ids[0])
280
289
            self._branch_revision_id = revision_ids[0]
 
290
        self._allow_leftmost_as_ghost = allow_leftmost_as_ghost
 
291
        self._set_basis()
 
292
    
 
293
    def _set_basis(self):
 
294
        try:
 
295
            self._basis_tree = self.branch.repository.revision_tree(
 
296
                self._branch_revision_id)
 
297
        except errors.NoSuchRevision:
 
298
            if self._allow_leftmost_as_ghost:
 
299
                self._basis_tree = self.branch.repository.revision_tree(
 
300
                    _mod_revision.NULL_REVISION)
 
301
            else:
 
302
                raise
281
303
 
282
304
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
283
305
        """See MutableTree.set_parent_trees()."""
284
306
        if len(parents_list) == 0:
285
307
            self._parent_ids = []
286
 
            self._basis_tree = self.branch.repository.revision_tree(None)
 
308
            self._basis_tree = self.branch.repository.revision_tree(
 
309
                                   _mod_revision.NULL_REVISION)
287
310
        else:
288
311
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
289
312
                # a ghost in the left most parent
290
313
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
291
314
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
292
315
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
293
 
                import pdb; pdb.set_trace()
294
 
                self._basis_tree = self.branch.repository.revision_tree(None)
 
316
                self._basis_tree = self.branch.repository.revision_tree(
 
317
                                       _mod_revision.NULL_REVISION)
295
318
            else:
296
319
                self._basis_tree = parents_list[0][1]
297
320
            self._branch_revision_id = parents_list[0][0]