~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/knit.py

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

• reverse the comparison (4632.1.1 to 5200.3.1)
• stop comparing with revision 5200.3.1

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

69

69

    lru_cache,

70

70

    pack,

71

71

    progress,

72

 

    static_tuple,

73

72

    trace,

74

73

    tsort,

75

74

    tuned_gzip,

76

 

    ui,

77

75

    )

78

76

""")

79

77

from bzrlib import (

1195

1193

    def get_known_graph_ancestry(self, keys):

1196

1194

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

1197

1195

        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

1196

        kg = _mod_graph.KnownGraph(parent_map)

1206

1197

        return kg

1207

1198

 

1520

1511

                if source is parent_maps[0]:

1521

1512

                    # this KnitVersionedFiles

1522

1513

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

1523

 

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

 

1514

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

1524

1515

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

1525

1516

                        yield KnitContentFactory(key, global_map[key],

1526

 

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

 

1517

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

1527

1518

                else:

1528

1519

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

1529

1520

                    for record in vf.get_record_stream(keys, ordering,

1598

1589

        # key = basis_parent, value = index entry to add

1599

1590

        buffered_index_entries = {}

1600

1591

        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

1592

            buffered = False

1609

1593

            parents = record.parents

1610

1594

            if record.storage_kind in delta_types:

1712

1696

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

1713

1697

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

1714

1698

            # entries for later insertion)

1715

 

            all_entries = []

1716

1699

            for key in buffered_index_entries:

1717

1700

                index_entries = buffered_index_entries[key]

1718

 

                all_entries.extend(index_entries)

1719

 

            self._index.add_records(

1720

 

                all_entries, missing_compression_parents=True)

 

1701

                self._index.add_records(index_entries,

 

1702

                    missing_compression_parents=True)

1721

1703

 

1722

1704

    def get_missing_compression_parent_keys(self):

1723

1705

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

1756

1738

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

1757

1739

        """

1758

1740

        if pb is None:

1759

 

            pb = ui.ui_factory.nested_progress_bar()

 

1741

            pb = progress.DummyProgress()

1760

1742

        keys = set(keys)

1761

1743

        total = len(keys)

1762

1744

        done = False

2369

2351

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

2370

2352

        no-eol, line-delta, fulltext.

2371

2353

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

2372

 

        that the compressed data starts at.

 

2354

        that the the compressed data starts at.

2373

2355

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

2374

2356

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

2375

2357

        REVISION_ID.

2788

2770

 

2789

2771

class _KeyRefs(object):

2790

2772

 

2791

 

    def __init__(self, track_new_keys=False):

 

2773

    def __init__(self):

2792

2774

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

2793

2775

        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

2776

 

2806

2777

    def add_references(self, key, refs):

2807

2778

        # Record the new references

2814

2785

        # Discard references satisfied by the new key

2815

2786

        self.add_key(key)

2816

2787

 

2817

 

    def get_new_keys(self):

2818

 

        return self.new_keys

2819

 

    

2820

2788

    def get_unsatisfied_refs(self):

2821

2789

        return self.refs.iterkeys()

2822

2790

 

2823

 

    def _satisfy_refs_for_key(self, key):

 

2791

    def add_key(self, key):

2824

2792

        try:

2825

2793

            del self.refs[key]

2826

2794

        except KeyError:

2827

2795

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

2828

2796

            pass

2829

2797

 

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):

 

2798

    def add_keys(self, keys):

2837

2799

        for key in keys:

2838

 

            self._satisfy_refs_for_key(key)

 

2800

            self.add_key(key)

2839

2801

 

2840

2802

    def get_referrers(self):

2841

2803

        result = set()

2946

2908

        if not random_id:

2947

2909

            present_nodes = self._get_entries(keys)

2948

2910

            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

2911

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

2954

 

                    parents != passed_parents):

2955

 

                    node_refs = static_tuple.as_tuples(node_refs)

 

2912

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

2956

2913

                    raise KnitCorrupt(self, "inconsistent details in add_records"

2957

 

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

 

2914

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

2958

2915

                del keys[key]

2959

2916

        result = []

2960

2917

        if self._parents:

3008

2965

        # If updating this, you should also update

3009

2966

        # groupcompress._GCGraphIndex.get_missing_parents

3010

2967

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

3011

 

        self._key_dependencies.satisfy_refs_for_keys(

 

2968

        self._key_dependencies.add_keys(

3012

2969

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

3013

2970

        return frozenset(self._key_dependencies.get_unsatisfied_refs())

3014

2971

 

3709

3666

 

3710

3667

try:

3711

3668

    from bzrlib._knit_load_data_pyx import _load_data_c as _load_data

3712

 

except ImportError, e:

3713

 

    osutils.failed_to_load_extension(e)

 

3669

except ImportError:

3714

3670

    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