/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 bzrlib/memorytree.py

  • Committer: Robert Collins
  • Date: 2007-07-15 15:40:37 UTC
  • mto: (2592.3.33 repository)
  • mto: This revision was merged to the branch mainline in revision 2624.
  • Revision ID: robertc@robertcollins.net-20070715154037-3ar8g89decddc9su
Make GraphIndex accept nodes as key, value, references, so that the method
signature is closer to what a simple key->value index delivers. Also
change the behaviour when the reference list count is zero to accept
key, value as nodes, and emit key, value to make it identical in that case
to a simple key->value index. This may not be a good idea, but for now it
seems ok.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/memorytree.py
 
1
# Copyright (C) 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""MemoryTree object.
 
18
 
 
19
See MemoryTree for more details.
 
20
"""
 
21
 
 
22
 
 
23
from copy import deepcopy
 
24
 
 
25
from bzrlib import (
 
26
    errors,
 
27
    mutabletree,
 
28
    revision as _mod_revision,
 
29
    )
 
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
31
from bzrlib.osutils import sha_file
 
32
from bzrlib.mutabletree import needs_tree_write_lock
 
33
from bzrlib.transport.memory import MemoryTransport
 
34
 
 
35
 
 
36
class MemoryTree(mutabletree.MutableTree):
 
37
    """A MemoryTree is a specialisation of MutableTree.
 
38
    
 
39
    It maintains nearly no state outside of read_lock and write_lock
 
40
    transactions. (it keeps a reference to the branch, and its last-revision
 
41
    only).
 
42
    """
 
43
 
 
44
    def __init__(self, branch, revision_id):
 
45
        """Construct a MemoryTree for branch using revision_id."""
 
46
        self.branch = branch
 
47
        self.bzrdir = branch.bzrdir
 
48
        self._branch_revision_id = revision_id
 
49
        self._locks = 0
 
50
        self._lock_mode = None
 
51
 
 
52
    @needs_tree_write_lock
 
53
    def _add(self, files, ids, kinds):
 
54
        """See MutableTree._add."""
 
55
        for f, file_id, kind in zip(files, ids, kinds):
 
56
            if kind is None:
 
57
                kind = 'file'
 
58
            if file_id is None:
 
59
                self._inventory.add_path(f, kind=kind)
 
60
            else:
 
61
                self._inventory.add_path(f, kind=kind, file_id=file_id)
 
62
 
 
63
    def basis_tree(self):
 
64
        """See Tree.basis_tree()."""
 
65
        return self._basis_tree
 
66
 
 
67
    @staticmethod
 
68
    def create_on_branch(branch):
 
69
        """Create a MemoryTree for branch, using the last-revision of branch."""
 
70
        revision_id = _mod_revision.ensure_null(branch.last_revision())
 
71
        if _mod_revision.is_null(revision_id):
 
72
            revision_id = None
 
73
        return MemoryTree(branch, revision_id)
 
74
 
 
75
    def _gather_kinds(self, files, kinds):
 
76
        """See MutableTree._gather_kinds.
 
77
        
 
78
        This implementation does not care about the file kind of
 
79
        missing files, so is a no-op.
 
80
        """
 
81
 
 
82
    def get_file(self, file_id):
 
83
        """See Tree.get_file."""
 
84
        return self._file_transport.get(self.id2path(file_id))
 
85
 
 
86
    def get_file_sha1(self, file_id, path=None):
 
87
        """See Tree.get_file_sha1()."""
 
88
        if path is None:
 
89
            path = self.id2path(file_id)
 
90
        stream = self._file_transport.get(path)
 
91
        return sha_file(stream)
 
92
 
 
93
    @needs_read_lock
 
94
    def get_parent_ids(self):
 
95
        """See Tree.get_parent_ids.
 
96
 
 
97
        This implementation returns the current cached value from
 
98
            self._parent_ids.
 
99
        """
 
100
        return list(self._parent_ids)
 
101
 
 
102
    def has_filename(self, filename):
 
103
        """See Tree.has_filename()."""
 
104
        return self._file_transport.has(filename)
 
105
 
 
106
    def is_executable(self, file_id, path=None):
 
107
        return self._inventory[file_id].executable
 
108
 
 
109
    def kind(self, file_id):
 
110
        return self._inventory[file_id].kind
 
111
 
 
112
    def mkdir(self, path, file_id=None):
 
113
        """See MutableTree.mkdir()."""
 
114
        self.add(path, file_id, 'directory')
 
115
        if file_id is None:
 
116
            file_id = self.path2id(path)
 
117
        self._file_transport.mkdir(path)
 
118
        return file_id
 
119
 
 
120
    @needs_read_lock
 
121
    def last_revision(self):
 
122
        """See MutableTree.last_revision."""
 
123
        return self._branch_revision_id
 
124
 
 
125
    def lock_read(self):
 
126
        """Lock the memory tree for reading.
 
127
 
 
128
        This triggers population of data from the branch for its revision.
 
129
        """
 
130
        self._locks += 1
 
131
        try:
 
132
            if self._locks == 1:
 
133
                self.branch.lock_read()
 
134
                self._lock_mode = "r"
 
135
                self._populate_from_branch()
 
136
        except:
 
137
            self._locks -= 1
 
138
            raise
 
139
 
 
140
    def lock_tree_write(self):
 
141
        """See MutableTree.lock_tree_write()."""
 
142
        self._locks += 1
 
143
        try:
 
144
            if self._locks == 1:
 
145
                self.branch.lock_read()
 
146
                self._lock_mode = "w"
 
147
                self._populate_from_branch()
 
148
            elif self._lock_mode == "r":
 
149
                raise errors.ReadOnlyError(self)
 
150
        except:
 
151
            self._locks -= 1
 
152
            raise
 
153
 
 
154
    def lock_write(self):
 
155
        """See MutableTree.lock_write()."""
 
156
        self._locks += 1
 
157
        try:
 
158
            if self._locks == 1:
 
159
                self.branch.lock_write()
 
160
                self._lock_mode = "w"
 
161
                self._populate_from_branch()
 
162
            elif self._lock_mode == "r":
 
163
                raise errors.ReadOnlyError(self)
 
164
        except:
 
165
            self._locks -= 1
 
166
            raise
 
167
 
 
168
    def _populate_from_branch(self):
 
169
        """Populate the in-tree state from the branch."""
 
170
        self._basis_tree = self.branch.repository.revision_tree(
 
171
            self._branch_revision_id)
 
172
        if self._branch_revision_id is None:
 
173
            self._parent_ids = []
 
174
        else:
 
175
            self._parent_ids = [self._branch_revision_id]
 
176
        self._inventory = deepcopy(self._basis_tree._inventory)
 
177
        self._file_transport = MemoryTransport()
 
178
        # TODO copy the revision trees content, or do it lazy, or something.
 
179
        inventory_entries = self._inventory.iter_entries()
 
180
        for path, entry in inventory_entries:
 
181
            if path == '':
 
182
                continue
 
183
            if entry.kind == 'directory':
 
184
                self._file_transport.mkdir(path)
 
185
            elif entry.kind == 'file':
 
186
                self._file_transport.put_file(path,
 
187
                    self._basis_tree.get_file(entry.file_id))
 
188
            else:
 
189
                raise NotImplementedError(self._populate_from_branch)
 
190
 
 
191
    def put_file_bytes_non_atomic(self, file_id, bytes):
 
192
        """See MutableTree.put_file_bytes_non_atomic."""
 
193
        self._file_transport.put_bytes(self.id2path(file_id), bytes)
 
194
 
 
195
    def unlock(self):
 
196
        """Release a lock.
 
197
 
 
198
        This frees all cached state when the last lock context for the tree is
 
199
        left.
 
200
        """
 
201
        if self._locks == 1:
 
202
            self._basis_tree = None
 
203
            self._parent_ids = []
 
204
            self._inventory = None
 
205
            try:
 
206
                self.branch.unlock()
 
207
            finally:
 
208
                self._locks = 0
 
209
                self._lock_mode = None
 
210
        else:
 
211
            self._locks -= 1
 
212
 
 
213
    @needs_tree_write_lock
 
214
    def unversion(self, file_ids):
 
215
        """Remove the file ids in file_ids from the current versioned set.
 
216
 
 
217
        When a file_id is unversioned, all of its children are automatically
 
218
        unversioned.
 
219
 
 
220
        :param file_ids: The file ids to stop versioning.
 
221
        :raises: NoSuchId if any fileid is not currently versioned.
 
222
        """
 
223
        # XXX: This should be in mutabletree, but the inventory-save action
 
224
        # is not relevant to memory tree. Until that is done in unlock by
 
225
        # working tree, we cannot share the implementation.
 
226
        for file_id in file_ids:
 
227
            if self._inventory.has_id(file_id):
 
228
                self._inventory.remove_recursive_id(file_id)
 
229
            else:
 
230
                raise errors.NoSuchId(self, file_id)
 
231
 
 
232
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
 
233
        """See MutableTree.set_parent_trees()."""
 
234
        for revision_id in revision_ids:
 
235
            _mod_revision.check_not_reserved_id(revision_id)
 
236
        if len(revision_ids) == 0:
 
237
            self._parent_ids = []
 
238
            self._basis_tree = self.branch.repository.revision_tree(None)
 
239
        else:
 
240
            self._parent_ids = revision_ids
 
241
            self._basis_tree = self.branch.repository.revision_tree(
 
242
                                    revision_ids[0])
 
243
            self._branch_revision_id = revision_ids[0]
 
244
 
 
245
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
246
        """See MutableTree.set_parent_trees()."""
 
247
        if len(parents_list) == 0:
 
248
            self._parent_ids = []
 
249
            self._basis_tree = self.branch.repository.revision_tree(None)
 
250
        else:
 
251
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
 
252
                # a ghost in the left most parent
 
253
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
 
254
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
 
255
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
 
256
                import pdb; pdb.set_trace()
 
257
                self._basis_tree = self.branch.repository.revision_tree(None)
 
258
            else:
 
259
                self._basis_tree = parents_list[0][1]
 
260
            self._branch_revision_id = parents_list[0][0]