/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/chk_serializer.py

  • Committer: John Arbash Meinel
  • Date: 2009-04-21 23:54:16 UTC
  • mto: (4300.1.7 groupcompress_info)
  • mto: This revision was merged to the branch mainline in revision 4301.
  • Revision ID: john@arbash-meinel.com-20090421235416-f0cz6ilf5cufbugi
https://launchpad.net/bugs/364900
Fix bug #364900, properly remove the 64kB that was just encoded in the copy.
Also, stop supporting None as a copy length in 'encode_copy_instruction'.
It was only used by the test suite, and it is good to pull that sort of thing out of
production code. (Besides, setting the copy to 64kB has the same effect.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/chk_serializer.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 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
17
17
"""Serializer object for CHK based inventory storage."""
18
18
 
19
19
from bzrlib import (
20
 
    bencode,
21
 
    cache_utf8,
22
20
    inventory,
23
 
    revision as _mod_revision,
 
21
    xml5,
24
22
    xml6,
25
 
    xml7,
26
23
    )
27
24
 
28
25
 
29
 
def _validate_properties(props, _decode=cache_utf8._utf8_decode):
30
 
    # TODO: we really want an 'isascii' check for key
31
 
    # Cast the utf8 properties into Unicode 'in place'
32
 
    for key, value in props.iteritems():
33
 
        props[key] = _decode(value)[0]
34
 
    return props
35
 
 
36
 
 
37
 
def _is_format_10(value):
38
 
    if value != 10:
39
 
        raise ValueError('Format number was not recognized, expected 10 got %d'
40
 
                         % (value,))
41
 
    return 10
42
 
 
43
 
 
44
 
class BEncodeRevisionSerializer1(object):
45
 
    """Simple revision serializer based around bencode.
46
 
    """
47
 
 
48
 
    squashes_xml_invalid_characters = False
49
 
 
50
 
    # Maps {key:(Revision attribute, bencode_type, validator)}
51
 
    # This tells us what kind we expect bdecode to create, what variable on
52
 
    # Revision we should be using, and a function to call to validate/transform
53
 
    # the type.
54
 
    # TODO: add a 'validate_utf8' for things like revision_id and file_id
55
 
    #       and a validator for parent-ids
56
 
    _schema = {'format': (None, int, _is_format_10),
57
 
               'committer': ('committer', str, cache_utf8.decode),
58
 
               'timezone': ('timezone', int, None),
59
 
               'timestamp': ('timestamp', str, float),
60
 
               'revision-id': ('revision_id', str, None),
61
 
               'parent-ids': ('parent_ids', list, None),
62
 
               'inventory-sha1': ('inventory_sha1', str, None),
63
 
               'message': ('message', str, cache_utf8.decode),
64
 
               'properties': ('properties', dict, _validate_properties),
65
 
    }
66
 
 
67
 
    def write_revision_to_string(self, rev):
68
 
        encode_utf8 = cache_utf8._utf8_encode
69
 
        # Use a list of tuples rather than a dict
70
 
        # This lets us control the ordering, so that we are able to create
71
 
        # smaller deltas
72
 
        ret = [
73
 
            ("format", 10),
74
 
            ("committer", encode_utf8(rev.committer)[0]),
75
 
        ]
76
 
        if rev.timezone is not None:
77
 
            ret.append(("timezone", rev.timezone))
78
 
        # For bzr revisions, the most common property is just 'branch-nick'
79
 
        # which changes infrequently.
80
 
        revprops = {}
81
 
        for key, value in rev.properties.iteritems():
82
 
            revprops[key] = encode_utf8(value)[0]
83
 
        ret.append(('properties', revprops))
84
 
        ret.extend([
85
 
            ("timestamp", "%.3f" % rev.timestamp),
86
 
            ("revision-id", rev.revision_id),
87
 
            ("parent-ids", rev.parent_ids),
88
 
            ("inventory-sha1", rev.inventory_sha1),
89
 
            ("message", encode_utf8(rev.message)[0]),
90
 
        ])
91
 
        return bencode.bencode(ret)
92
 
 
93
 
    def write_revision(self, rev, f):
94
 
        f.write(self.write_revision_to_string(rev))
95
 
 
96
 
    def read_revision_from_string(self, text):
97
 
        # TODO: consider writing a Revision decoder, rather than using the
98
 
        #       generic bencode decoder
99
 
        #       However, to decode all 25k revisions of bzr takes approx 1.3s
100
 
        #       If we remove all extra validation that goes down to about 1.2s.
101
 
        #       Of that time, probably 0.6s is spend in bencode.bdecode().
102
 
        #       Regardless 'time bzr log' of everything is 7+s, so 1.3s to
103
 
        #       extract revision texts isn't a majority of time.
104
 
        ret = bencode.bdecode(text)
105
 
        if not isinstance(ret, list):
106
 
            raise ValueError("invalid revision text")
107
 
        schema = self._schema
108
 
        # timezone is allowed to be missing, but should be set
109
 
        bits = {'timezone': None}
110
 
        for key, value in ret:
111
 
            # Will raise KeyError if not a valid part of the schema, or an
112
 
            # entry is given 2 times.
113
 
            var_name, expected_type, validator = schema[key]
114
 
            if value.__class__ is not expected_type:
115
 
                raise ValueError('key %s did not conform to the expected type'
116
 
                                 ' %s, but was %s'
117
 
                                 % (key, expected_type, type(value)))
118
 
            if validator is not None:
119
 
                value = validator(value)
120
 
            bits[var_name] = value
121
 
        if len(bits) != len(schema):
122
 
            missing = [key for key, (var_name, _, _) in schema.iteritems()
123
 
                       if var_name not in bits]
124
 
            raise ValueError('Revision text was missing expected keys %s.'
125
 
                             ' text %r' % (missing, text))
126
 
        del bits[None]  # Get rid of 'format' since it doesn't get mapped
127
 
        rev = _mod_revision.Revision(**bits)
128
 
        return rev
129
 
 
130
 
    def read_revision(self, f):
131
 
        return self.read_revision_from_string(f.read())
132
 
 
133
 
 
134
 
class CHKSerializerSubtree(BEncodeRevisionSerializer1, xml7.Serializer_v7):
 
26
class CHKSerializerSubtree(xml6.Serializer_v6):
135
27
    """A CHKInventory based serializer that supports tree references"""
136
28
 
137
29
    supported_kinds = set(['file', 'directory', 'symlink', 'tree-reference'])
139
31
    revision_format_num = None
140
32
    support_altered_by_hack = False
141
33
 
142
 
    def _unpack_entry(self, elt, entry_cache=None, return_from_cache=False):
 
34
    def _unpack_entry(self, elt):
143
35
        kind = elt.tag
144
36
        if not kind in self.supported_kinds:
145
37
            raise AssertionError('unsupported entry kind %s' % kind)
152
44
            return inventory.TreeReference(file_id, name, parent_id, revision,
153
45
                                           reference_revision)
154
46
        else:
155
 
            return xml7.Serializer_v7._unpack_entry(self, elt,
156
 
                entry_cache=entry_cache, return_from_cache=return_from_cache)
 
47
            return xml6.Serializer_v6._unpack_entry(self, elt)
157
48
 
158
49
    def __init__(self, node_size, search_key_name):
159
50
        self.maximum_size = node_size
160
51
        self.search_key_name = search_key_name
161
52
 
162
53
 
163
 
class CHKSerializer(xml6.Serializer_v6):
 
54
class CHKSerializer(xml5.Serializer_v5):
164
55
    """A CHKInventory based serializer with 'plain' behaviour."""
165
56
 
166
57
    format_num = '9'
173
64
 
174
65
 
175
66
chk_serializer_255_bigpage = CHKSerializer(65536, 'hash-255-way')
176
 
 
177
 
 
178
 
class CHKBEncodeSerializer(BEncodeRevisionSerializer1, CHKSerializer):
179
 
    """A CHKInventory and BEncode based serializer with 'plain' behaviour."""
180
 
 
181
 
    format_num = '10'
182
 
 
183
 
 
184
 
chk_bencode_serializer = CHKBEncodeSerializer(65536, 'hash-255-way')