← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/pack.py

(gz) Never raise KnownFailure in tests,
 use knownFailure method instead (Martin [gz])

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/pack.py
75
75
        """Return the bytes to finish a container."""
76
76
        return "E"
77
77
 
78
 
    def bytes_header(self, length, names):
79
 
        """Return the header for a Bytes record."""
 
78
    def bytes_record(self, bytes, names):
 
79
        """Return the bytes for a Bytes record with the given name and
 
80
        contents.
 
81
        """
80
82
        # Kind marker
81
83
        byte_sections = ["B"]
82
84
        # Length
83
 
        byte_sections.append(str(length) + "\n")
 
85
        byte_sections.append(str(len(bytes)) + "\n")
84
86
        # Names
85
87
        for name_tuple in names:
86
88
            # Make sure we're writing valid names.  Note that we will leave a
90
92
            byte_sections.append('\x00'.join(name_tuple) + "\n")
91
93
        # End of headers
92
94
        byte_sections.append("\n")
 
95
        # Finally, the contents.
 
96
        byte_sections.append(bytes)
 
97
        # XXX: This causes a memory copy of bytes in size, but is usually
 
98
        # faster than two write calls (12 vs 13 seconds to output a gig of
 
99
        # 1k records.) - results may differ on significantly larger records
 
100
        # like .iso's but as they should be rare in any case and thus not
 
101
        # likely to be the common case. The biggest issue is causing extreme
 
102
        # memory pressure in that case. One possibly improvement here is to
 
103
        # check the size of the content before deciding to join here vs call
 
104
        # write twice.
93
105
        return ''.join(byte_sections)
94
106
 
95
 
    def bytes_record(self, bytes, names):
96
 
        """Return the bytes for a Bytes record with the given name and
97
 
        contents.
98
 
 
99
 
        If the content may be large, construct the header separately and then
100
 
        stream out the contents.
101
 
        """
102
 
        return self.bytes_header(len(bytes), names) + bytes
103
 
 
104
107
 
105
108
class ContainerWriter(object):
106
109
    """A class for writing containers to a file.
110
113
        introduced by the begin() and end() methods.
111
114
    """
112
115
 
113
 
    # Join up headers with the body if writing fewer than this many bytes:
114
 
    # trades off memory usage and copying to do less IO ops.
115
 
    _JOIN_WRITES_THRESHOLD = 100000
116
 
 
117
116
    def __init__(self, write_func):
118
117
        """Constructor.
119
118
 
152
151
            and thus are only suitable for use by a ContainerReader.
153
152
        """
154
153
        current_offset = self.current_offset
155
 
        length = len(bytes)
156
 
        if length < self._JOIN_WRITES_THRESHOLD:
157
 
            self.write_func(self._serialiser.bytes_header(length, names)
158
 
                + bytes)
159
 
        else:
160
 
            self.write_func(self._serialiser.bytes_header(length, names))
161
 
            self.write_func(bytes)
 
154
        serialised_record = self._serialiser.bytes_record(bytes, names)
 
155
        self.write_func(serialised_record)
162
156
        self.records_written += 1
163
157
        # return a memo of where we wrote data to allow random access.
164
158
        return current_offset, self.current_offset - current_offset
339
333
                # risk that the same unicode string has been encoded two
340
334
                # different ways.
341
335
                if name_tuple in all_names:
342
 
                    raise errors.DuplicateRecordNameError(name_tuple[0])
 
336
                    raise errors.DuplicateRecordNameError(name_tuple)
343
337
                all_names.add(name_tuple)
344
338
        excess_bytes = self.reader_func(1)
345
339
        if excess_bytes != '':