← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/dirstate.py

  • Committer: Matt Nordhoff
  • Date: 2009-04-04 02:50:01 UTC
  • mfrom: (4253 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4256.
  • Revision ID: mnordhoff@mattnordhoff.com-20090404025001-z1403k0tatmc8l91
Merge bzr.dev, fixing conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/dirstate.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
"""DirState objects record the state of a directory and its bzr metadata.
18
18
 
82
82
'a' is an absent entry: In that tree the id is not present at this path.
83
83
'd' is a directory entry: This path in this tree is a directory with the
84
84
    current file id. There is no fingerprint for directories.
85
 
'f' is a file entry: As for directory, but its a file. The fingerprint is a
86
 
    sha1 value.
 
85
'f' is a file entry: As for directory, but it's a file. The fingerprint is the
 
86
    sha1 value of the file's canonical form, i.e. after any read filters have
 
87
    been applied to the convenience form stored in the working tree.
87
88
'l' is a symlink entry: As for directory, but a symlink. The fingerprint is the
88
89
    link target.
89
90
't' is a reference to a nested subtree; the fingerprint is the referenced
99
100
 
100
101
--- Format 1 had the following different definition: ---
101
102
rows = dirname, NULL, basename, NULL, MINIKIND, NULL, fileid_utf8, NULL,
102
 
    WHOLE NUMBER (* size *), NULL, packed stat, NULL, sha1|symlink target, 
 
103
    WHOLE NUMBER (* size *), NULL, packed stat, NULL, sha1|symlink target,
103
104
    {PARENT ROW}
104
105
PARENT ROW = NULL, revision_utf8, NULL, MINIKIND, NULL, dirname, NULL,
105
106
    basename, NULL, WHOLE NUMBER (* size *), NULL, "y" | "n", NULL,
130
131
operations for the less common but still occurs a lot status/diff/commit
131
132
on specific files). Operations on specific files involve a scan for all
132
133
the children of a path, *in every involved tree*, which the current
133
 
format did not accommodate. 
 
134
format did not accommodate.
134
135
----
135
136
 
136
137
Design priorities:
148
149
 
149
150
Memory representation:
150
151
 vector of all directories, and vector of the childen ?
151
 
   i.e. 
152
 
     root_entrie = (direntry for root, [parent_direntries_for_root]), 
 
152
   i.e.
 
153
     root_entrie = (direntry for root, [parent_direntries_for_root]),
153
154
     dirblocks = [
154
155
     ('', ['data for achild', 'data for bchild', 'data for cchild'])
155
156
     ('dir', ['achild', 'cchild', 'echild'])
158
159
    - in-order for serialisation - this is 'dirblock' grouping.
159
160
    - insertion of a file '/a' affects only the '/' child-vector, that is, to
160
161
      insert 10K elements from scratch does not generates O(N^2) memoves of a
161
 
      single vector, rather each individual, which tends to be limited to a 
162
 
      manageable number. Will scale badly on trees with 10K entries in a 
 
162
      single vector, rather each individual, which tends to be limited to a
 
163
      manageable number. Will scale badly on trees with 10K entries in a
163
164
      single directory. compare with Inventory.InventoryDirectory which has
164
165
      a dictionary for the children. No bisect capability, can only probe for
165
166
      exact matches, or grab all elements and sort.
166
167
    - What's the risk of error here? Once we have the base format being processed
167
 
      we should have a net win regardless of optimality. So we are going to 
 
168
      we should have a net win regardless of optimality. So we are going to
168
169
      go with what seems reasonable.
169
170
open questions:
170
171
 
262
263
        # return '%X.%X' % (int(st.st_mtime), st.st_mode)
263
264
 
264
265
 
 
266
class SHA1Provider(object):
 
267
    """An interface for getting sha1s of a file."""
 
268
 
 
269
    def sha1(self, abspath):
 
270
        """Return the sha1 of a file given its absolute path."""
 
271
        raise NotImplementedError(self.sha1)
 
272
 
 
273
    def stat_and_sha1(self, abspath):
 
274
        """Return the stat and sha1 of a file given its absolute path.
 
275
        
 
276
        Note: the stat should be the stat of the physical file
 
277
        while the sha may be the sha of its canonical content.
 
278
        """
 
279
        raise NotImplementedError(self.stat_and_sha1)
 
280
 
 
281
 
 
282
class DefaultSHA1Provider(SHA1Provider):
 
283
    """A SHA1Provider that reads directly from the filesystem."""
 
284
 
 
285
    def sha1(self, abspath):
 
286
        """Return the sha1 of a file given its absolute path."""
 
287
        return osutils.sha_file_by_name(abspath)
 
288
 
 
289
    def stat_and_sha1(self, abspath):
 
290
        """Return the stat and sha1 of a file given its absolute path."""
 
291
        file_obj = file(abspath, 'rb')
 
292
        try:
 
293
            statvalue = os.fstat(file_obj.fileno())
 
294
            sha1 = osutils.sha_file(file_obj)
 
295
        finally:
 
296
            file_obj.close()
 
297
        return statvalue, sha1
 
298
 
 
299
 
265
300
class DirState(object):
266
301
    """Record directory and metadata state for fast access.
267
302
 
320
355
    HEADER_FORMAT_2 = '#bazaar dirstate flat format 2\n'
321
356
    HEADER_FORMAT_3 = '#bazaar dirstate flat format 3\n'
322
357
 
323
 
    def __init__(self, path):
 
358
    def __init__(self, path, sha1_provider):
324
359
        """Create a  DirState object.
325
360
 
326
361
        :param path: The path at which the dirstate file on disk should live.
 
362
        :param sha1_provider: an object meeting the SHA1Provider interface.
327
363
        """
328
364
        # _header_state and _dirblock_state represent the current state
329
365
        # of the dirstate metadata and the per-row data respectiely.
331
367
        # IN_MEMORY_UNMODIFIED indicates that what we have in memory
332
368
        #   is the same as is on disk
333
369
        # IN_MEMORY_MODIFIED indicates that we have a modified version
334
 
        #   of what is on disk. 
 
370
        #   of what is on disk.
335
371
        # In future we will add more granularity, for instance _dirblock_state
336
372
        # will probably support partially-in-memory as a separate variable,
337
373
        # allowing for partially-in-memory unmodified and partially-in-memory
338
374
        # modified states.
339
375
        self._header_state = DirState.NOT_IN_MEMORY
340
376
        self._dirblock_state = DirState.NOT_IN_MEMORY
341
 
        # If true, an error has been detected while updating the dirstate, and 
 
377
        # If true, an error has been detected while updating the dirstate, and
342
378
        # for safety we're not going to commit to disk.
343
379
        self._changes_aborted = False
344
380
        self._dirblocks = []
355
391
        self._cutoff_time = None
356
392
        self._split_path_cache = {}
357
393
        self._bisect_page_size = DirState.BISECT_PAGE_SIZE
 
394
        self._sha1_provider = sha1_provider
358
395
        if 'hashcache' in debug.debug_flags:
359
396
            self._sha1_file = self._sha1_file_and_mutter
360
397
        else:
361
 
            self._sha1_file = osutils.sha_file_by_name
 
398
            self._sha1_file = self._sha1_provider.sha1
362
399
        # These two attributes provide a simple cache for lookups into the
363
400
        # dirstate in-memory vectors. By probing respectively for the last
364
401
        # block, and for the next entry, we save nearly 2 bisections per path
374
411
        """Add a path to be tracked.
375
412
 
376
413
        :param path: The path within the dirstate - '' is the root, 'foo' is the
377
 
            path foo within the root, 'foo/bar' is the path bar within foo 
 
414
            path foo within the root, 'foo/bar' is the path bar within foo
378
415
            within the root.
379
416
        :param file_id: The file id of the path being added.
380
 
        :param kind: The kind of the path, as a string like 'file', 
 
417
        :param kind: The kind of the path, as a string like 'file',
381
418
            'directory', etc.
382
419
        :param stat: The output of os.lstat for the path.
383
 
        :param fingerprint: The sha value of the file,
 
420
        :param fingerprint: The sha value of the file's canonical form (i.e.
 
421
            after any read filters have been applied),
384
422
            or the target of a symlink,
385
423
            or the referenced revision id for tree-references,
386
424
            or '' for directories.
387
425
        """
388
426
        # adding a file:
389
 
        # find the block its in. 
 
427
        # find the block its in.
390
428
        # find the location in the block.
391
429
        # check its not there
392
430
        # add it.
405
443
        # in the parent, or according to the special treatment for the root
406
444
        if basename == '.' or basename == '..':
407
445
            raise errors.InvalidEntryName(path)
408
 
        # now that we've normalised, we need the correct utf8 path and 
 
446
        # now that we've normalised, we need the correct utf8 path and
409
447
        # dirname and basename elements. This single encode and split should be
410
448
        # faster than three separate encodes.
411
449
        utf8path = (dirname + '/' + basename).strip('/').encode('utf8')
439
477
            # check the path is not in the tree
440
478
            block = self._dirblocks[block_index][1]
441
479
            entry_index, _ = self._find_entry_index(first_key, block)
442
 
            while (entry_index < len(block) and 
 
480
            while (entry_index < len(block) and
443
481
                block[entry_index][0][0:2] == first_key[0:2]):
444
482
                if block[entry_index][1][0][0] not in 'ar':
445
483
                    # this path is in the dirstate in the current tree.
935
973
 
936
974
    def _discard_merge_parents(self):
937
975
        """Discard any parents trees beyond the first.
938
 
        
 
976
 
939
977
        Note that if this fails the dirstate is corrupted.
940
978
 
941
979
        After this function returns the dirstate contains 2 trees, neither of
1011
1049
                raise AssertionError("bad dirname %r" % dirname)
1012
1050
        block_index, present = self._find_block_index_from_key((dirname, '', ''))
1013
1051
        if not present:
1014
 
            ## In future, when doing partial parsing, this should load and 
 
1052
            ## In future, when doing partial parsing, this should load and
1015
1053
            # populate the entire block.
1016
1054
            self._dirblocks.insert(block_index, (dirname, []))
1017
1055
        return block_index
1029
1067
        if new_entries[0][0][0:2] != ('', ''):
1030
1068
            raise AssertionError(
1031
1069
                "Missing root row %r" % (new_entries[0][0],))
1032
 
        # The two blocks here are deliberate: the root block and the 
 
1070
        # The two blocks here are deliberate: the root block and the
1033
1071
        # contents-of-root block.
1034
1072
        self._dirblocks = [('', []), ('', [])]
1035
1073
        current_block = self._dirblocks[0][1]
1159
1197
        # one to use it. we use _right here because there are two
1160
1198
        # '' blocks - the root, and the contents of root
1161
1199
        # we always have a minimum of 2 in self._dirblocks: root and
1162
 
        # root-contents, and for '', we get 2 back, so this is 
 
1200
        # root-contents, and for '', we get 2 back, so this is
1163
1201
        # simple and correct:
1164
1202
        present = (block_index < len(self._dirblocks) and
1165
1203
            self._dirblocks[block_index][0] == key[0])
1194
1232
        return entry_index, present
1195
1233
 
1196
1234
    @staticmethod
1197
 
    def from_tree(tree, dir_state_filename):
 
1235
    def from_tree(tree, dir_state_filename, sha1_provider=None):
1198
1236
        """Create a dirstate from a bzr Tree.
1199
1237
 
1200
1238
        :param tree: The tree which should provide parent information and
1201
1239
            inventory ids.
 
1240
        :param sha1_provider: an object meeting the SHA1Provider interface.
 
1241
            If None, a DefaultSHA1Provider is used.
1202
1242
        :return: a DirState object which is currently locked for writing.
1203
1243
            (it was locked by DirState.initialize)
1204
1244
        """
1205
 
        result = DirState.initialize(dir_state_filename)
 
1245
        result = DirState.initialize(dir_state_filename,
 
1246
            sha1_provider=sha1_provider)
1206
1247
        try:
1207
1248
            tree.lock_read()
1208
1249
            try:
1569
1610
        # when -Dhashcache is turned on, this is monkey-patched in to log
1570
1611
        # file reads
1571
1612
        trace.mutter("dirstate sha1 " + abspath)
1572
 
        return osutils.sha_file_by_name(abspath)
 
1613
        return self._sha1_provider.sha1(abspath)
1573
1614
 
1574
1615
    def _is_executable(self, mode, old_executable):
1575
1616
        """Is this file executable?"""
1588
1629
        #       already in memory. However, this really needs to be done at a
1589
1630
        #       higher level, because there either won't be anything on disk,
1590
1631
        #       or the thing on disk will be a file.
1591
 
        return os.readlink(abspath.encode(osutils._fs_enc))
 
1632
        fs_encoding = osutils._fs_enc
 
1633
        if isinstance(abspath, unicode):
 
1634
            # abspath is defined as the path to pass to lstat. readlink is
 
1635
            # buggy in python < 2.6 (it doesn't encode unicode path into FS
 
1636
            # encoding), so we need to encode ourselves knowing that unicode
 
1637
            # paths are produced by UnicodeDirReader on purpose.
 
1638
            abspath = abspath.encode(fs_encoding)
 
1639
        target = os.readlink(abspath)
 
1640
        if fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1641
            # Change encoding if needed
 
1642
            target = target.decode(fs_encoding).encode('UTF-8')
 
1643
        return target
1592
1644
 
1593
1645
    def get_ghosts(self):
1594
1646
        """Return a list of the parent tree revision ids that are ghosts."""
1798
1850
                if present:
1799
1851
                    entry = self._dirblocks[block_index][1][entry_index]
1800
1852
                    if entry[1][tree_index][0] in 'fdlt':
1801
 
                        # this is the result we are looking for: the  
 
1853
                        # this is the result we are looking for: the
1802
1854
                        # real home of this file_id in this tree.
1803
1855
                        return entry
1804
1856
                    if entry[1][tree_index][0] == 'a':
1818
1870
            return None, None
1819
1871
 
1820
1872
    @classmethod
1821
 
    def initialize(cls, path):
 
1873
    def initialize(cls, path, sha1_provider=None):
1822
1874
        """Create a new dirstate on path.
1823
1875
 
1824
1876
        The new dirstate will be an empty tree - that is it has no parents,
1825
1877
        and only a root node - which has id ROOT_ID.
1826
1878
 
1827
1879
        :param path: The name of the file for the dirstate.
 
1880
        :param sha1_provider: an object meeting the SHA1Provider interface.
 
1881
            If None, a DefaultSHA1Provider is used.
1828
1882
        :return: A write-locked DirState object.
1829
1883
        """
1830
1884
        # This constructs a new DirState object on a path, sets the _state_file
1832
1886
        # stock empty dirstate information - a root with ROOT_ID, no children,
1833
1887
        # and no parents. Finally it calls save() to ensure that this data will
1834
1888
        # persist.
1835
 
        result = cls(path)
 
1889
        if sha1_provider is None:
 
1890
            sha1_provider = DefaultSHA1Provider()
 
1891
        result = cls(path, sha1_provider)
1836
1892
        # root dir and root dir contents with no children.
1837
1893
        empty_tree_dirblocks = [('', []), ('', [])]
1838
1894
        # a new root directory, with a NULLSTAT.
1866
1922
            size = 0
1867
1923
            executable = False
1868
1924
        elif kind == 'symlink':
1869
 
            # We don't support non-ascii targets for symlinks yet.
1870
 
            fingerprint = str(inv_entry.symlink_target or '')
 
1925
            if inv_entry.symlink_target is None:
 
1926
                fingerprint = ''
 
1927
            else:
 
1928
                fingerprint = inv_entry.symlink_target.encode('utf8')
1871
1929
            size = 0
1872
1930
            executable = False
1873
1931
        elif kind == 'file':
1885
1943
    def _iter_child_entries(self, tree_index, path_utf8):
1886
1944
        """Iterate over all the entries that are children of path_utf.
1887
1945
 
1888
 
        This only returns entries that are present (not in 'a', 'r') in 
 
1946
        This only returns entries that are present (not in 'a', 'r') in
1889
1947
        tree_index. tree_index data is not refreshed, so if tree 0 is used,
1890
1948
        results may differ from that obtained if paths were statted to
1891
1949
        determine what ones were directories.
1922
1980
                        else:
1923
1981
                            path = entry[0][1]
1924
1982
                        next_pending_dirs.append(path)
1925
 
    
 
1983
 
1926
1984
    def _iter_entries(self):
1927
1985
        """Iterate over all the entries in the dirstate.
1928
1986
 
1969
2027
        return len(self._parents) - len(self._ghosts)
1970
2028
 
1971
2029
    @staticmethod
1972
 
    def on_file(path):
 
2030
    def on_file(path, sha1_provider=None):
1973
2031
        """Construct a DirState on the file at path "path".
1974
2032
 
 
2033
        :param path: The path at which the dirstate file on disk should live.
 
2034
        :param sha1_provider: an object meeting the SHA1Provider interface.
 
2035
            If None, a DefaultSHA1Provider is used.
1975
2036
        :return: An unlocked DirState object, associated with the given path.
1976
2037
        """
1977
 
        result = DirState(path)
 
2038
        if sha1_provider is None:
 
2039
            sha1_provider = DefaultSHA1Provider()
 
2040
        result = DirState(path, sha1_provider)
1978
2041
        return result
1979
2042
 
1980
2043
    def _read_dirblocks_if_needed(self):
1981
2044
        """Read in all the dirblocks from the file if they are not in memory.
1982
 
        
 
2045
 
1983
2046
        This populates self._dirblocks, and sets self._dirblock_state to
1984
2047
        IN_MEMORY_UNMODIFIED. It is not currently ready for incremental block
1985
2048
        loading.
2110
2173
 
2111
2174
        :param parent_ids: A list of parent tree revision ids.
2112
2175
        :param dirblocks: A list containing one tuple for each directory in the
2113
 
            tree. Each tuple contains the directory path and a list of entries 
 
2176
            tree. Each tuple contains the directory path and a list of entries
2114
2177
            found in that directory.
2115
2178
        """
2116
2179
        # our memory copy is now authoritative.
2150
2213
        """Set the parent trees for the dirstate.
2151
2214
 
2152
2215
        :param trees: A list of revision_id, tree tuples. tree must be provided
2153
 
            even if the revision_id refers to a ghost: supply an empty tree in 
 
2216
            even if the revision_id refers to a ghost: supply an empty tree in
2154
2217
            this case.
2155
2218
        :param ghosts: A list of the revision_ids that are ghosts at the time
2156
2219
            of setting.
2157
 
        """ 
2158
 
        # TODO: generate a list of parent indexes to preserve to save 
 
2220
        """
 
2221
        # TODO: generate a list of parent indexes to preserve to save
2159
2222
        # processing specific parent trees. In the common case one tree will
2160
2223
        # be preserved - the left most parent.
2161
2224
        # TODO: if the parent tree is a dirstate, we might want to walk them
2166
2229
        # map and then walk the new parent trees only, mapping them into the
2167
2230
        # dirstate. Walk the dirstate at the same time to remove unreferenced
2168
2231
        # entries.
2169
 
        # for now: 
2170
 
        # sketch: loop over all entries in the dirstate, cherry picking 
 
2232
        # for now:
 
2233
        # sketch: loop over all entries in the dirstate, cherry picking
2171
2234
        # entries from the parent trees, if they are not ghost trees.
2172
2235
        # after we finish walking the dirstate, all entries not in the dirstate
2173
2236
        # are deletes, so we want to append them to the end as per the design
2178
2241
        #   links. We dont't trivially use the inventory from other trees
2179
2242
        #   because this leads to either double touching, or to accessing
2180
2243
        #   missing keys,
2181
 
        # - find other keys containing a path 
2182
 
        # We accumulate each entry via this dictionary, including the root 
 
2244
        # - find other keys containing a path
 
2245
        # We accumulate each entry via this dictionary, including the root
2183
2246
        by_path = {}
2184
2247
        id_index = {}
2185
2248
        # we could do parallel iterators, but because file id data may be
2189
2252
        # parent, but for now the common cases are adding a new parent (merge),
2190
2253
        # and replacing completely (commit), and commit is more common: so
2191
2254
        # optimise merge later.
2192
 
        
 
2255
 
2193
2256
        # ---- start generation of full tree mapping data
2194
2257
        # what trees should we use?
2195
2258
        parent_trees = [tree for rev_id, tree in trees if rev_id not in ghosts]
2196
 
        # how many trees do we end up with 
 
2259
        # how many trees do we end up with
2197
2260
        parent_count = len(parent_trees)
2198
2261
 
2199
2262
        # one: the current tree
2204
2267
            by_path[entry[0]] = [entry[1][0]] + \
2205
2268
                [DirState.NULL_PARENT_DETAILS] * parent_count
2206
2269
            id_index[entry[0][2]] = set([entry[0]])
2207
 
        
 
2270
 
2208
2271
        # now the parent trees:
2209
2272
        for tree_index, tree in enumerate(parent_trees):
2210
2273
            # the index is off by one, adjust it.
2224
2287
                # avoid checking all known paths for the id when generating a
2225
2288
                # new entry at this path: by adding the id->path mapping last,
2226
2289
                # all the mappings are valid and have correct relocation
2227
 
                # records where needed. 
 
2290
                # records where needed.
2228
2291
                file_id = entry.file_id
2229
2292
                path_utf8 = path.encode('utf8')
2230
2293
                dirname, basename = osutils.split(path_utf8)
2241
2304
                        # This is the vertical axis in the matrix, all pointing
2242
2305
                        # to the real path.
2243
2306
                        by_path[entry_key][tree_index] = ('r', path_utf8, 0, False, '')
2244
 
                # by path consistency: Insert into an existing path record (trivial), or 
 
2307
                # by path consistency: Insert into an existing path record (trivial), or
2245
2308
                # add a new one with relocation pointers for the other tree indexes.
2246
2309
                if new_entry_key in id_index[file_id]:
2247
2310
                    # there is already an entry where this data belongs, just insert it.
2260
2323
                            new_details.append(DirState.NULL_PARENT_DETAILS)
2261
2324
                        else:
2262
2325
                            # grab any one entry, use it to find the right path.
2263
 
                            # TODO: optimise this to reduce memory use in highly 
 
2326
                            # TODO: optimise this to reduce memory use in highly
2264
2327
                            # fragmented situations by reusing the relocation
2265
2328
                            # records.
2266
2329
                            a_key = iter(id_index[file_id]).next()
2299
2362
        return sorted(entry_list, key=_key)
2300
2363
 
2301
2364
    def set_state_from_inventory(self, new_inv):
2302
 
        """Set new_inv as the current state. 
 
2365
        """Set new_inv as the current state.
2303
2366
 
2304
2367
        This API is called by tree transform, and will usually occur with
2305
2368
        existing parent trees.
2311
2374
                "set_state_from_inventory called; please mutate the tree instead")
2312
2375
        self._read_dirblocks_if_needed()
2313
2376
        # sketch:
2314
 
        # Two iterators: current data and new data, both in dirblock order. 
 
2377
        # Two iterators: current data and new data, both in dirblock order.
2315
2378
        # We zip them together, which tells about entries that are new in the
2316
2379
        # inventory, or removed in the inventory, or present in both and
2317
 
        # possibly changed.  
 
2380
        # possibly changed.
2318
2381
        #
2319
2382
        # You might think we could just synthesize a new dirstate directly
2320
2383
        # since we're processing it in the right order.  However, we need to
2469
2532
        :param minikind: The type for the entry ('f' == 'file', 'd' ==
2470
2533
                'directory'), etc.
2471
2534
        :param executable: Should the executable bit be set?
2472
 
        :param fingerprint: Simple fingerprint for new entry: sha1 for files, 
2473
 
            referenced revision id for subtrees, etc.
 
2535
        :param fingerprint: Simple fingerprint for new entry: canonical-form
 
2536
            sha1 for files, referenced revision id for subtrees, etc.
2474
2537
        :param packed_stat: Packed stat value for new entry.
2475
2538
        :param size: Size information for new entry
2476
2539
        :param path_utf8: key[0] + '/' + key[1], just passed in to avoid doing
2520
2583
                num_present_parents = self._num_present_parents()
2521
2584
                for lookup_index in xrange(1, num_present_parents + 1):
2522
2585
                    # grab any one entry, use it to find the right path.
2523
 
                    # TODO: optimise this to reduce memory use in highly 
 
2586
                    # TODO: optimise this to reduce memory use in highly
2524
2587
                    # fragmented situations by reusing the relocation
2525
2588
                    # records.
2526
2589
                    update_block_index, present = \
2543
2606
            block.insert(entry_index, new_entry)
2544
2607
            existing_keys.add(key)
2545
2608
        else:
2546
 
            # Does the new state matter? 
 
2609
            # Does the new state matter?
2547
2610
            block[entry_index][1][0] = new_details
2548
2611
            # parents cannot be affected by what we do.
2549
 
            # other occurences of this id can be found 
 
2612
            # other occurences of this id can be found
2550
2613
            # from the id index.
2551
2614
            # ---
2552
2615
            # tree index consistency: All other paths for this id in this tree
2585
2648
    def _validate(self):
2586
2649
        """Check that invariants on the dirblock are correct.
2587
2650
 
2588
 
        This can be useful in debugging; it shouldn't be necessary in 
 
2651
        This can be useful in debugging; it shouldn't be necessary in
2589
2652
        normal code.
2590
2653
 
2591
2654
        This must be called with a lock held.
2660
2723
        # For each file id, for each tree: either
2661
2724
        # the file id is not present at all; all rows with that id in the
2662
2725
        # key have it marked as 'absent'
2663
 
        # OR the file id is present under exactly one name; any other entries 
 
2726
        # OR the file id is present under exactly one name; any other entries
2664
2727
        # that mention that id point to the correct name.
2665
2728
        #
2666
2729
        # We check this with a dict per tree pointing either to the present
2713
2776
                        # absent; should not occur anywhere else
2714
2777
                        this_tree_map[file_id] = None, this_path
2715
2778
                    elif minikind == 'r':
2716
 
                        # relocation, must occur at expected location 
 
2779
                        # relocation, must occur at expected location
2717
2780
                        this_tree_map[file_id] = tree_state[1], this_path
2718
2781
                    else:
2719
2782
                        this_tree_map[file_id] = this_path, this_path
2807
2870
    (saved_minikind, saved_link_or_sha1, saved_file_size,
2808
2871
     saved_executable, saved_packed_stat) = entry[1][0]
2809
2872
 
 
2873
    if minikind == 'd' and saved_minikind == 't':
 
2874
        minikind = 't'
2810
2875
    if (minikind == saved_minikind
2811
2876
        and packed_stat == saved_packed_stat):
2812
2877
        # The stat hasn't changed since we saved, so we can re-use the
2830
2895
            and stat_value.st_ctime < state._cutoff_time
2831
2896
            and len(entry[1]) > 1
2832
2897
            and entry[1][1][0] != 'a'):
2833
 
                # Could check for size changes for further optimised
2834
 
                # avoidance of sha1's. However the most prominent case of
2835
 
                # over-shaing is during initial add, which this catches.
 
2898
            # Could check for size changes for further optimised
 
2899
            # avoidance of sha1's. However the most prominent case of
 
2900
            # over-shaing is during initial add, which this catches.
 
2901
            # Besides, if content filtering happens, size and sha
 
2902
            # are calculated at the same time, so checking just the size
 
2903
            # gains nothing w.r.t. performance.
2836
2904
            link_or_sha1 = state._sha1_file(abspath)
2837
2905
            entry[1][0] = ('f', link_or_sha1, stat_value.st_size,
2838
2906
                           executable, packed_stat)
2991
3059
                        if target_details[2] == source_details[2]:
2992
3060
                            if link_or_sha1 is None:
2993
3061
                                # Stat cache miss:
2994
 
                                file_obj = file(path_info[4], 'rb')
2995
 
                                try:
2996
 
                                    statvalue = os.fstat(file_obj.fileno())
2997
 
                                    link_or_sha1 = osutils.sha_file(file_obj)
2998
 
                                finally:
2999
 
                                    file_obj.close()
 
3062
                                statvalue, link_or_sha1 = \
 
3063
                                    self.state._sha1_provider.stat_and_sha1(
 
3064
                                    path_info[4])
3000
3065
                                self.state._observed_sha1(entry, link_or_sha1,
3001
3066
                                    statvalue)
3002
3067
                            content_change = (link_or_sha1 != source_details[1])
3181
3246
        search_specific_files = self.search_specific_files
3182
3247
        searched_specific_files = self.searched_specific_files
3183
3248
        splitpath = osutils.splitpath
3184
 
        # sketch: 
 
3249
        # sketch:
3185
3250
        # compare source_index and target_index at or under each element of search_specific_files.
3186
3251
        # follow the following comparison table. Note that we only want to do diff operations when
3187
 
        # the target is fdl because thats when the walkdirs logic will have exposed the pathinfo 
 
3252
        # the target is fdl because thats when the walkdirs logic will have exposed the pathinfo
3188
3253
        # for the target.
3189
3254
        # cases:
3190
 
        # 
 
3255
        #
3191
3256
        # Source | Target | disk | action
3192
3257
        #   r    | fdlt   |      | add source to search, add id path move and perform
3193
3258
        #        |        |      | diff check on source-target
3194
 
        #   r    | fdlt   |  a   | dangling file that was present in the basis. 
 
3259
        #   r    | fdlt   |  a   | dangling file that was present in the basis.
3195
3260
        #        |        |      | ???
3196
3261
        #   r    |  a     |      | add source to search
3197
 
        #   r    |  a     |  a   | 
 
3262
        #   r    |  a     |  a   |
3198
3263
        #   r    |  r     |      | this path is present in a non-examined tree, skip.
3199
3264
        #   r    |  r     |  a   | this path is present in a non-examined tree, skip.
3200
3265
        #   a    | fdlt   |      | add new id
3308
3373
                            raise AssertionError()
3309
3374
                        del current_dir_info[1][bzr_index]
3310
3375
            # walk until both the directory listing and the versioned metadata
3311
 
            # are exhausted. 
 
3376
            # are exhausted.
3312
3377
            if (block_index < len(self.state._dirblocks) and
3313
3378
                osutils.is_inside(current_root, self.state._dirblocks[block_index][0])):
3314
3379
                current_block = self.state._dirblocks[block_index]
3405
3470
                while (current_entry is not None or
3406
3471
                    current_path_info is not None):
3407
3472
                    if current_entry is None:
3408
 
                        # the check for path_handled when the path is adnvaced
 
3473
                        # the check for path_handled when the path is advanced
3409
3474
                        # will yield this path if needed.
3410
3475
                        pass
3411
3476
                    elif current_path_info is None:
3475
3540
                            if current_path_info[2] in ('directory'):
3476
3541
                                del current_dir_info[1][path_index]
3477
3542
                                path_index -= 1
3478
 
                        # dont descend the disk iterator into any tree 
 
3543
                        # dont descend the disk iterator into any tree
3479
3544
                        # paths.
3480
3545
                        if current_path_info[2] == 'tree-reference':
3481
3546
                            del current_dir_info[1][path_index]