~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/knit.py

• browse files at revision 4614
• compare with another revision
• download diff
• download tarball
• view history from revision 4614

• reverse the comparison (4614 to 5401)
• stop comparing with revision 5401

Show diffs side-by-side

added

removed

bzrlib/knit.py

1

 

# Copyright (C) 2006-2010 Canonical Ltd

 

1

# Copyright (C) 2005, 2006, 2007, 2008 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

68

68

    index as _mod_index,

69

69

    lru_cache,

70

70

    pack,

71

 

    patiencediff,

72

71

    progress,

73

 

    static_tuple,

74

72

    trace,

75

73

    tsort,

76

74

    tuned_gzip,

77

 

    ui,

78

75

    )

79

76

""")

80

77

from bzrlib import (

81

78

    errors,

82

79

    osutils,

 

80

    patiencediff,

83

81

    )

84

82

from bzrlib.errors import (

85

83

    FileExists,

1192

1190

        generator = _VFContentMapGenerator(self, [key])

1193

1191

        return generator._get_content(key)

1194

1192

 

1195

 

    def get_known_graph_ancestry(self, keys):

1196

 

        """Get a KnownGraph instance with the ancestry of keys."""

1197

 

        parent_map, missing_keys = self._index.find_ancestry(keys)

1198

 

        for fallback in self._fallback_vfs:

1199

 

            if not missing_keys:

1200

 

                break

1201

 

            (f_parent_map, f_missing_keys) = fallback._index.find_ancestry(

1202

 

                                                missing_keys)

1203

 

            parent_map.update(f_parent_map)

1204

 

            missing_keys = f_missing_keys

1205

 

        kg = _mod_graph.KnownGraph(parent_map)

1206

 

        return kg

1207

 

 

1208

1193

    def get_parent_map(self, keys):

1209

1194

        """Get a map of the graph parents of keys.

1210

1195

 

1520

1505

                if source is parent_maps[0]:

1521

1506

                    # this KnitVersionedFiles

1522

1507

                    records = [(key, positions[key][1]) for key in keys]

1523

 

                    for key, raw_data in self._read_records_iter_unchecked(records):

 

1508

                    for key, raw_data, sha1 in self._read_records_iter_raw(records):

1524

1509

                        (record_details, index_memo, _) = positions[key]

1525

1510

                        yield KnitContentFactory(key, global_map[key],

1526

 

                            record_details, None, raw_data, self._factory.annotated, None)

 

1511

                            record_details, sha1, raw_data, self._factory.annotated, None)

1527

1512

                else:

1528

1513

                    vf = self._fallback_vfs[parent_maps.index(source) - 1]

1529

1514

                    for record in vf.get_record_stream(keys, ordering,

1598

1583

        # key = basis_parent, value = index entry to add

1599

1584

        buffered_index_entries = {}

1600

1585

        for record in stream:

1601

 

            kind = record.storage_kind

1602

 

            if kind.startswith('knit-') and kind.endswith('-gz'):

1603

 

                # Check that the ID in the header of the raw knit bytes matches

1604

 

                # the record metadata.

1605

 

                raw_data = record._raw_record

1606

 

                df, rec = self._parse_record_header(record.key, raw_data)

1607

 

                df.close()

1608

1586

            buffered = False

1609

1587

            parents = record.parents

1610

1588

            if record.storage_kind in delta_types:

1712

1690

            # There were index entries buffered at the end of the stream,

1713

1691

            # So these need to be added (if the index supports holding such

1714

1692

            # entries for later insertion)

1715

 

            all_entries = []

1716

1693

            for key in buffered_index_entries:

1717

1694

                index_entries = buffered_index_entries[key]

1718

 

                all_entries.extend(index_entries)

1719

 

            self._index.add_records(

1720

 

                all_entries, missing_compression_parents=True)

 

1695

                self._index.add_records(index_entries,

 

1696

                    missing_compression_parents=True)

1721

1697

 

1722

1698

    def get_missing_compression_parent_keys(self):

1723

1699

        """Return an iterable of keys of missing compression parents.

1756

1732

        :return: An iterator over (line, key).

1757

1733

        """

1758

1734

        if pb is None:

1759

 

            pb = ui.ui_factory.nested_progress_bar()

 

1735

            pb = progress.DummyProgress()

1760

1736

        keys = set(keys)

1761

1737

        total = len(keys)

1762

1738

        done = False

2369

2345

    FLAGS is a comma separated list of flags about the record. Values include

2370

2346

        no-eol, line-delta, fulltext.

2371

2347

    BYTE_OFFSET is the ascii representation of the byte offset in the data file

2372

 

        that the compressed data starts at.

 

2348

        that the the compressed data starts at.

2373

2349

    LENGTH is the ascii representation of the length of the data file.

2374

2350

    PARENT_ID a utf-8 revision id prefixed by a '.' that is a parent of

2375

2351

        REVISION_ID.

2584

2560

        except KeyError:

2585

2561

            raise RevisionNotPresent(key, self)

2586

2562

 

2587

 

    def find_ancestry(self, keys):

2588

 

        """See CombinedGraphIndex.find_ancestry()"""

2589

 

        prefixes = set(key[:-1] for key in keys)

2590

 

        self._load_prefixes(prefixes)

2591

 

        result = {}

2592

 

        parent_map = {}

2593

 

        missing_keys = set()

2594

 

        pending_keys = list(keys)

2595

 

        # This assumes that keys will not reference parents in a different

2596

 

        # prefix, which is accurate so far.

2597

 

        while pending_keys:

2598

 

            key = pending_keys.pop()

2599

 

            if key in parent_map:

2600

 

                continue

2601

 

            prefix = key[:-1]

2602

 

            try:

2603

 

                suffix_parents = self._kndx_cache[prefix][0][key[-1]][4]

2604

 

            except KeyError:

2605

 

                missing_keys.add(key)

2606

 

            else:

2607

 

                parent_keys = tuple([prefix + (suffix,)

2608

 

                                     for suffix in suffix_parents])

2609

 

                parent_map[key] = parent_keys

2610

 

                pending_keys.extend([p for p in parent_keys

2611

 

                                        if p not in parent_map])

2612

 

        return parent_map, missing_keys

2613

 

 

2614

2563

    def get_parent_map(self, keys):

2615

2564

        """Get a map of the parents of keys.

2616

2565

 

2788

2737

 

2789

2738

class _KeyRefs(object):

2790

2739

 

2791

 

    def __init__(self, track_new_keys=False):

 

2740

    def __init__(self):

2792

2741

        # dict mapping 'key' to 'set of keys referring to that key'

2793

2742

        self.refs = {}

2794

 

        if track_new_keys:

2795

 

            # set remembering all new keys

2796

 

            self.new_keys = set()

2797

 

        else:

2798

 

            self.new_keys = None

2799

 

 

2800

 

    def clear(self):

2801

 

        if self.refs:

2802

 

            self.refs.clear()

2803

 

        if self.new_keys:

2804

 

            self.new_keys.clear()

2805

2743

 

2806

2744

    def add_references(self, key, refs):

2807

2745

        # Record the new references

2814

2752

        # Discard references satisfied by the new key

2815

2753

        self.add_key(key)

2816

2754

 

2817

 

    def get_new_keys(self):

2818

 

        return self.new_keys

2819

 

    

2820

2755

    def get_unsatisfied_refs(self):

2821

2756

        return self.refs.iterkeys()

2822

2757

 

2823

 

    def _satisfy_refs_for_key(self, key):

 

2758

    def add_key(self, key):

2824

2759

        try:

2825

2760

            del self.refs[key]

2826

2761

        except KeyError:

2827

2762

            # No keys depended on this key.  That's ok.

2828

2763

            pass

2829

2764

 

2830

 

    def add_key(self, key):

2831

 

        # satisfy refs for key, and remember that we've seen this key.

2832

 

        self._satisfy_refs_for_key(key)

2833

 

        if self.new_keys is not None:

2834

 

            self.new_keys.add(key)

2835

 

 

2836

 

    def satisfy_refs_for_keys(self, keys):

 

2765

    def add_keys(self, keys):

2837

2766

        for key in keys:

2838

 

            self._satisfy_refs_for_key(key)

 

2767

            self.add_key(key)

2839

2768

 

2840

2769

    def get_referrers(self):

2841

2770

        result = set()

2946

2875

        if not random_id:

2947

2876

            present_nodes = self._get_entries(keys)

2948

2877

            for (index, key, value, node_refs) in present_nodes:

2949

 

                parents = node_refs[:1]

2950

 

                # Sometimes these are passed as a list rather than a tuple

2951

 

                passed = static_tuple.as_tuples(keys[key])

2952

 

                passed_parents = passed[1][:1]

2953

2878

                if (value[0] != keys[key][0][0] or

2954

 

                    parents != passed_parents):

2955

 

                    node_refs = static_tuple.as_tuples(node_refs)

 

2879

                    node_refs[:1] != keys[key][1][:1]):

2956

2880

                    raise KnitCorrupt(self, "inconsistent details in add_records"

2957

 

                        ": %s %s" % ((value, node_refs), passed))

 

2881

                        ": %s %s" % ((value, node_refs), keys[key]))

2958

2882

                del keys[key]

2959

2883

        result = []

2960

2884

        if self._parents:

3008

2932

        # If updating this, you should also update

3009

2933

        # groupcompress._GCGraphIndex.get_missing_parents

3010

2934

        # We may have false positives, so filter those out.

3011

 

        self._key_dependencies.satisfy_refs_for_keys(

 

2935

        self._key_dependencies.add_keys(

3012

2936

            self.get_parent_map(self._key_dependencies.get_unsatisfied_refs()))

3013

2937

        return frozenset(self._key_dependencies.get_unsatisfied_refs())

3014

2938

 

3125

3049

            options.append('no-eol')

3126

3050

        return options

3127

3051

 

3128

 

    def find_ancestry(self, keys):

3129

 

        """See CombinedGraphIndex.find_ancestry()"""

3130

 

        return self._graph_index.find_ancestry(keys, 0)

3131

 

 

3132

3052

    def get_parent_map(self, keys):

3133

3053

        """Get a map of the parents of keys.

3134

3054

 

3417

3337

            raise exc_class, exc_value, exc_traceback

3418

3338

 

3419

3339

 

 

3340

# Deprecated, use PatienceSequenceMatcher instead

 

3341

KnitSequenceMatcher = patiencediff.PatienceSequenceMatcher

 

3342

 

 

3343

 

3420

3344

def annotate_knit(knit, revision_id):

3421

3345

    """Annotate a knit with no cached annotations.

3422

3346

 

3705

3629

 

3706

3630

try:

3707

3631

    from bzrlib._knit_load_data_pyx import _load_data_c as _load_data

3708

 

except ImportError, e:

3709

 

    osutils.failed_to_load_extension(e)

 

3632

except ImportError:

3710

3633

    from bzrlib._knit_load_data_py import _load_data_py as _load_data

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1