← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/repository.py

  • Committer: Patch Queue Manager
  • Date: 2011-10-14 16:54:26 UTC
  • mfrom: (6216.1.1 remove-this-file)
  • Revision ID: pqm@pqm.ubuntu.com-20111014165426-tjix4e6idryf1r2z
(jelmer) Remove an accidentally committed .THIS file. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/repository.py
25
25
 
26
26
from bzrlib import (
27
27
    bencode,
 
28
    commands,
28
29
    errors,
 
30
    estimate_compressed_size,
29
31
    graph,
30
32
    osutils,
31
33
    pack,
 
34
    trace,
32
35
    ui,
33
 
    versionedfile,
34
36
    )
35
37
from bzrlib.bzrdir import BzrDir
36
38
from bzrlib.smart.request import (
39
41
    SuccessfulSmartServerResponse,
40
42
    )
41
43
from bzrlib.repository import _strip_NULL_ghosts, network_format_registry
42
 
from bzrlib.recordcounter import RecordCounter
43
44
from bzrlib import revision as _mod_revision
44
45
from bzrlib.versionedfile import (
45
46
    NetworkRecordStream,
83
84
            recreate_search trusts that clients will look for missing things
84
85
            they expected and get it from elsewhere.
85
86
        """
 
87
        if search_bytes == 'everything':
 
88
            return graph.EverythingResult(repository), None
86
89
        lines = search_bytes.split('\n')
87
90
        if lines[0] == 'ancestry-of':
88
91
            heads = lines[1:]
141
144
        finally:
142
145
            repository.unlock()
143
146
 
 
147
_lsprof_count = 0
144
148
 
145
149
class SmartServerRepositoryGetParentMap(SmartServerRepositoryRequest):
146
150
    """Bzr 1.2+ - get parent data for revisions during a graph search."""
180
184
        finally:
181
185
            repository.unlock()
182
186
 
183
 
    def _do_repository_request(self, body_bytes):
184
 
        repository = self._repository
185
 
        revision_ids = set(self._revision_ids)
186
 
        include_missing = 'include-missing:' in revision_ids
187
 
        if include_missing:
188
 
            revision_ids.remove('include-missing:')
189
 
        body_lines = body_bytes.split('\n')
190
 
        search_result, error = self.recreate_search_from_recipe(
191
 
            repository, body_lines)
192
 
        if error is not None:
193
 
            return error
194
 
        # TODO might be nice to start up the search again; but thats not
195
 
        # written or tested yet.
196
 
        client_seen_revs = set(search_result.get_keys())
197
 
        # Always include the requested ids.
198
 
        client_seen_revs.difference_update(revision_ids)
199
 
        lines = []
200
 
        repo_graph = repository.get_graph()
 
187
    def _expand_requested_revs(self, repo_graph, revision_ids, client_seen_revs,
 
188
                               include_missing, max_size=65536):
201
189
        result = {}
202
190
        queried_revs = set()
203
 
        size_so_far = 0
 
191
        estimator = estimate_compressed_size.ZLibEstimator(max_size)
204
192
        next_revs = revision_ids
205
193
        first_loop_done = False
206
194
        while next_revs:
228
216
                    # add parents to the result
229
217
                    result[encoded_id] = parents
230
218
                    # Approximate the serialized cost of this revision_id.
231
 
                    size_so_far += 2 + len(encoded_id) + sum(map(len, parents))
 
219
                    line = '%s %s\n' % (encoded_id, ' '.join(parents))
 
220
                    estimator.add_content(line)
232
221
            # get all the directly asked for parents, and then flesh out to
233
222
            # 64K (compressed) or so. We do one level of depth at a time to
234
223
            # stay in sync with the client. The 250000 magic number is
235
224
            # estimated compression ratio taken from bzr.dev itself.
236
 
            if self.no_extra_results or (
237
 
                first_loop_done and size_so_far > 250000):
 
225
            if self.no_extra_results or (first_loop_done and estimator.full()):
 
226
                trace.mutter('size: %d, z_size: %d'
 
227
                             % (estimator._uncompressed_size_added,
 
228
                                estimator._compressed_size_added))
238
229
                next_revs = set()
239
230
                break
240
231
            # don't query things we've already queried
241
 
            next_revs.difference_update(queried_revs)
 
232
            next_revs = next_revs.difference(queried_revs)
242
233
            first_loop_done = True
 
234
        return result
 
235
 
 
236
    def _do_repository_request(self, body_bytes):
 
237
        repository = self._repository
 
238
        revision_ids = set(self._revision_ids)
 
239
        include_missing = 'include-missing:' in revision_ids
 
240
        if include_missing:
 
241
            revision_ids.remove('include-missing:')
 
242
        body_lines = body_bytes.split('\n')
 
243
        search_result, error = self.recreate_search_from_recipe(
 
244
            repository, body_lines)
 
245
        if error is not None:
 
246
            return error
 
247
        # TODO might be nice to start up the search again; but thats not
 
248
        # written or tested yet.
 
249
        client_seen_revs = set(search_result.get_keys())
 
250
        # Always include the requested ids.
 
251
        client_seen_revs.difference_update(revision_ids)
 
252
 
 
253
        repo_graph = repository.get_graph()
 
254
        result = self._expand_requested_revs(repo_graph, revision_ids,
 
255
                                             client_seen_revs, include_missing)
243
256
 
244
257
        # sorting trivially puts lexographically similar revision ids together.
245
258
        # Compression FTW.
 
259
        lines = []
246
260
        for revision, parents in sorted(result.items()):
247
261
            lines.append(' '.join((revision, ) + tuple(parents)))
248
262
 
414
428
    def do_repository_request(self, repository, to_network_name):
415
429
        """Get a stream for inserting into a to_format repository.
416
430
 
 
431
        The request body is 'search_bytes', a description of the revisions
 
432
        being requested.
 
433
 
 
434
        In 2.3 this verb added support for search_bytes == 'everything'.  Older
 
435
        implementations will respond with a BadSearch error, and clients should
 
436
        catch this and fallback appropriately.
 
437
 
417
438
        :param repository: The repository to stream from.
418
439
        :param to_network_name: The network name of the format of the target
419
440
            repository.
491
512
 
492
513
 
493
514
class SmartServerRepositoryGetStream_1_19(SmartServerRepositoryGetStream):
 
515
    """The same as Repository.get_stream, but will return stream CHK formats to
 
516
    clients.
 
517
 
 
518
    See SmartServerRepositoryGetStream._should_fake_unknown.
 
519
    
 
520
    New in 1.19.
 
521
    """
494
522
 
495
523
    def _should_fake_unknown(self):
496
524
        """Returns False; we don't need to workaround bugs in 1.19+ clients."""
506
534
        for record in substream:
507
535
            if record.storage_kind in ('chunked', 'fulltext'):
508
536
                serialised = record_to_fulltext_bytes(record)
509
 
            elif record.storage_kind == 'inventory-delta':
510
 
                serialised = record_to_inventory_delta_bytes(record)
511
537
            elif record.storage_kind == 'absent':
512
538
                raise ValueError("Absent factory for %s" % (record.key,))
513
539
            else: