/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/chk_map.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
42
42
import heapq
43
43
import threading
44
44
 
45
 
from bzrlib import lazy_import
 
45
from . import lazy_import
46
46
lazy_import.lazy_import(globals(), """
47
 
from bzrlib import (
 
47
from breezy import (
48
48
    errors,
49
49
    )
50
50
""")
51
 
from bzrlib import (
 
51
from . import (
52
52
    errors,
53
53
    lru_cache,
54
54
    osutils,
56
56
    static_tuple,
57
57
    trace,
58
58
    )
59
 
from bzrlib.static_tuple import StaticTuple
 
59
from .static_tuple import StaticTuple
60
60
 
61
61
# approx 4MB
62
62
# If each line is 50 bytes, and you have 255 internal pages, with 255-way fan
138
138
        has_deletes = False
139
139
        # Check preconditions first.
140
140
        as_st = StaticTuple.from_sequence
141
 
        new_items = set([as_st(key) for (old, key, value) in delta
142
 
                         if key is not None and old is None])
 
141
        new_items = {as_st(key) for (old, key, value) in delta
 
142
                         if key is not None and old is None}
143
143
        existing_new = list(self.iteritems(key_filter=new_items))
144
144
        if existing_new:
145
145
            raise errors.InconsistentDeltaDelta(delta,
158
158
 
159
159
    def _ensure_root(self):
160
160
        """Ensure that the root node is an object not a key."""
161
 
        if type(self._root_node) is StaticTuple:
 
161
        if isinstance(self._root_node, StaticTuple):
162
162
            # Demand-load the root
163
163
            self._root_node = self._get_node(self._root_node)
164
164
 
172
172
        :param node: A tuple key or node object.
173
173
        :return: A node object.
174
174
        """
175
 
        if type(node) is StaticTuple:
 
175
        if isinstance(node, StaticTuple):
176
176
            bytes = self._read_bytes(node)
177
177
            return _deserialise(bytes, node,
178
178
                search_key_func=self._search_key_func)
209
209
                key_str = ' None'
210
210
        result.append('%s%r %s%s' % (indent, prefix, node.__class__.__name__,
211
211
                                     key_str))
212
 
        if type(node) is InternalNode:
 
212
        if isinstance(node, InternalNode):
213
213
            # Trigger all child nodes to get loaded
214
214
            list(node._iter_nodes(self._store))
215
215
            for prefix, sub in sorted(node._items.iteritems()):
243
243
        root_key = klass._create_directly(store, initial_value,
244
244
            maximum_size=maximum_size, key_width=key_width,
245
245
            search_key_func=search_key_func)
246
 
        if type(root_key) is not StaticTuple:
 
246
        if not isinstance(root_key, StaticTuple):
247
247
            raise AssertionError('we got a %s instead of a StaticTuple'
248
248
                                 % (type(root_key),))
249
249
        return root_key
331
331
        def process_node(node, path, a_map, pending):
332
332
            # take a node and expand it
333
333
            node = a_map._get_node(node)
334
 
            if type(node) == LeafNode:
 
334
            if isinstance(node, LeafNode):
335
335
                path = (node._key, path)
336
336
                for key, value in node._items.items():
337
337
                    # For a LeafNode, the key is a serialized_key, rather than
369
369
            # time?
370
370
            self_node = self._get_node(self_node)
371
371
            basis_node = basis._get_node(basis_node)
372
 
            if (type(self_node) == InternalNode
373
 
                and type(basis_node) == InternalNode):
 
372
            if (isinstance(self_node, InternalNode)
 
373
                and isinstance(basis_node, InternalNode)):
374
374
                # Matching internal nodes
375
375
                process_common_internal_nodes(self_node, basis_node)
376
 
            elif (type(self_node) == LeafNode
377
 
                  and type(basis_node) == LeafNode):
 
376
            elif (isinstance(self_node, LeafNode)
 
377
                  and isinstance(basis_node, LeafNode)):
378
378
                process_common_leaf_nodes(self_node, basis_node)
379
379
            else:
380
380
                process_node(self_node, self_path, self, self_pending)
389
389
            # A better implementation would probably have a reverse map
390
390
            # back to the children of a node, and jump straight to it when
391
391
            # a common node is detected, the proceed to remove the already
392
 
            # pending children. bzrlib.graph has a searcher module with a
 
392
            # pending children. breezy.graph has a searcher module with a
393
393
            # similar problem.
394
394
            while key_path is not None:
395
395
                key, key_path = key_path
519
519
 
520
520
    def key(self):
521
521
        """Return the key for this map."""
522
 
        if type(self._root_node) is StaticTuple:
 
522
        if isinstance(self._root_node, StaticTuple):
523
523
            return self._root_node
524
524
        else:
525
525
            return self._root_node._key
550
550
 
551
551
    def _node_key(self, node):
552
552
        """Get the key for a node whether it's a tuple or node."""
553
 
        if type(node) is tuple:
 
553
        if isinstance(node, tuple):
554
554
            node = StaticTuple.from_sequence(node)
555
 
        if type(node) is StaticTuple:
 
555
        if isinstance(node, StaticTuple):
556
556
            return node
557
557
        else:
558
558
            return node._key
561
561
        """remove key from the map."""
562
562
        key = StaticTuple.from_sequence(key)
563
563
        self._ensure_root()
564
 
        if type(self._root_node) is InternalNode:
 
564
        if isinstance(self._root_node, InternalNode):
565
565
            unmapped = self._root_node.unmap(self._store, key,
566
566
                check_remap=check_remap)
567
567
        else:
571
571
    def _check_remap(self):
572
572
        """Check if nodes can be collapsed."""
573
573
        self._ensure_root()
574
 
        if type(self._root_node) is InternalNode:
 
574
        if isinstance(self._root_node, InternalNode):
575
575
            self._root_node = self._root_node._check_remap(self._store)
576
576
 
577
577
    def _save(self):
579
579
 
580
580
        :return: The key of the root node.
581
581
        """
582
 
        if type(self._root_node) is StaticTuple:
 
582
        if isinstance(self._root_node, StaticTuple):
583
583
            # Already saved.
584
584
            return self._root_node
585
585
        keys = list(self._root_node.serialise(self._store))
1228
1228
            # new child needed:
1229
1229
            child = self._new_child(search_key, LeafNode)
1230
1230
        old_len = len(child)
1231
 
        if type(child) is LeafNode:
 
1231
        if isinstance(child, LeafNode):
1232
1232
            old_size = child._current_size()
1233
1233
        else:
1234
1234
            old_size = None
1240
1240
            self._items[search_key] = child
1241
1241
            self._key = None
1242
1242
            new_node = self
1243
 
            if type(child) is LeafNode:
 
1243
            if isinstance(child, LeafNode):
1244
1244
                if old_size is None:
1245
1245
                    # The old node was an InternalNode which means it has now
1246
1246
                    # collapsed, so we need to check if it will chain to a
1293
1293
        :return: An iterable of the keys inserted by this operation.
1294
1294
        """
1295
1295
        for node in self._items.itervalues():
1296
 
            if type(node) is StaticTuple:
 
1296
            if isinstance(node, StaticTuple):
1297
1297
                # Never deserialised.
1298
1298
                continue
1299
1299
            if node._key is not None:
1310
1310
        lines.append('%s\n' % (self._search_prefix,))
1311
1311
        prefix_len = len(self._search_prefix)
1312
1312
        for prefix, node in sorted(self._items.items()):
1313
 
            if type(node) is StaticTuple:
 
1313
            if isinstance(node, StaticTuple):
1314
1314
                key = node[0]
1315
1315
            else:
1316
1316
                key = node._key[0]
1355
1355
            raise AssertionError("unserialised nodes have no refs.")
1356
1356
        refs = []
1357
1357
        for value in self._items.itervalues():
1358
 
            if type(value) is StaticTuple:
 
1358
            if isinstance(value, StaticTuple):
1359
1359
                refs.append(value)
1360
1360
            else:
1361
1361
                refs.append(value.key())
1394
1394
        if len(self._items) == 1:
1395
1395
            # this node is no longer needed:
1396
1396
            return self._items.values()[0]
1397
 
        if type(unmapped) is InternalNode:
 
1397
        if isinstance(unmapped, InternalNode):
1398
1398
            return self
1399
1399
        if check_remap:
1400
1400
            return self._check_remap(store)
1440
1440
        #   c) With 255-way fan out, we don't want to read all 255 and destroy
1441
1441
        #      the page cache, just to determine that we really don't need it.
1442
1442
        for node, _ in self._iter_nodes(store, batch_size=16):
1443
 
            if type(node) is InternalNode:
 
1443
            if isinstance(node, InternalNode):
1444
1444
                # Without looking at any leaf nodes, we are sure
1445
1445
                return self
1446
1446
            for key, value in node._items.iteritems():
1525
1525
            bytes = record.get_bytes_as('fulltext')
1526
1526
            node = _deserialise(bytes, record.key,
1527
1527
                                search_key_func=self._search_key_func)
1528
 
            if type(node) is InternalNode:
 
1528
            if isinstance(node, InternalNode):
1529
1529
                # Note we don't have to do node.refs() because we know that
1530
1530
                # there are no children that have been pushed into this node
1531
1531
                # Note: Using as_st() here seemed to save 1.2MB, which would
1725
1725
 
1726
1726
 
1727
1727
try:
1728
 
    from bzrlib._chk_map_pyx import (
 
1728
    from breezy._chk_map_pyx import (
1729
1729
        _bytes_to_text_key,
1730
1730
        _search_key_16,
1731
1731
        _search_key_255,
1732
1732
        _deserialise_leaf_node,
1733
1733
        _deserialise_internal_node,
1734
1734
        )
1735
 
except ImportError, e:
 
1735
except ImportError as e:
1736
1736
    osutils.failed_to_load_extension(e)
1737
 
    from bzrlib._chk_map_py import (
 
1737
    from breezy._chk_map_py import (
1738
1738
        _bytes_to_text_key,
1739
1739
        _search_key_16,
1740
1740
        _search_key_255,
1751
1751
    This generally shouldn't be used in production code, but it can be helpful
1752
1752
    to debug problems.
1753
1753
    """
1754
 
    if type(key) is not StaticTuple:
 
1754
    if not isinstance(key, StaticTuple):
1755
1755
        raise TypeError('key %r is not StaticTuple but %s' % (key, type(key)))
1756
1756
    if len(key) != 1:
1757
1757
        raise ValueError('key %r should have length 1, not %d' % (key, len(key),))
1758
 
    if type(key[0]) is not str:
 
1758
    if not isinstance(key[0], str):
1759
1759
        raise TypeError('key %r should hold a str, not %r'
1760
1760
                        % (key, type(key[0])))
1761
1761
    if not key[0].startswith('sha1:'):