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

  • Committer: Andrew Bennetts
  • Date: 2009-10-21 11:13:40 UTC
  • mto: This revision was merged to the branch mainline in revision 4762.
  • Revision ID: andrew.bennetts@canonical.com-20091021111340-w7x4d5yf83qwjncc
Add test that WSGI glue allows request handlers to access paths above that request's. backing transport, so long as it is within the WSGI app's backing transport.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2008, 2009 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
 
17
18
"""Copying of history from one branch to another.
18
19
 
19
20
The basic plan is that every branch knows the history of everything
22
23
branch.
23
24
"""
24
25
 
25
 
from __future__ import absolute_import
26
 
 
27
26
import operator
28
27
 
29
 
from .lazy_import import lazy_import
 
28
from bzrlib.lazy_import import lazy_import
30
29
lazy_import(globals(), """
31
 
from breezy import (
 
30
from bzrlib import (
32
31
    tsort,
33
 
    )
34
 
from breezy.bzr import (
35
32
    versionedfile,
36
 
    vf_search,
37
33
    )
38
34
""")
39
 
from . import (
 
35
import bzrlib
 
36
from bzrlib import (
40
37
    errors,
41
 
    ui,
42
 
    )
43
 
from .i18n import gettext
44
 
from .revision import NULL_REVISION
45
 
from .sixish import (
46
 
    viewvalues,
47
 
    )
48
 
from .trace import mutter
 
38
    symbol_versioning,
 
39
    )
 
40
from bzrlib.revision import NULL_REVISION
 
41
from bzrlib.trace import mutter
 
42
import bzrlib.ui
49
43
 
50
44
 
51
45
class RepoFetcher(object):
56
50
    """
57
51
 
58
52
    def __init__(self, to_repository, from_repository, last_revision=None,
59
 
        find_ghosts=True, fetch_spec=None):
 
53
        pb=None, find_ghosts=True, fetch_spec=None):
60
54
        """Create a repo fetcher.
61
55
 
62
56
        :param last_revision: If set, try to limit to the data this revision
63
57
            references.
64
 
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
65
 
            If set, this overrides last_revision.
66
58
        :param find_ghosts: If True search the entire history for ghosts.
 
59
        :param pb: ProgressBar object to use; deprecated and ignored.
 
60
            This method will just create one on top of the stack.
67
61
        """
 
62
        if pb is not None:
 
63
            symbol_versioning.warn(
 
64
                symbol_versioning.deprecated_in((1, 14, 0))
 
65
                % "pb parameter to RepoFetcher.__init__")
 
66
            # and for simplicity it is in fact ignored
68
67
        # repository.fetch has the responsibility for short-circuiting
69
68
        # attempts to copy between a repository and itself.
70
69
        self.to_repository = to_repository
76
75
        self.find_ghosts = find_ghosts
77
76
        self.from_repository.lock_read()
78
77
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
79
 
               str(self.from_repository), str(self.from_repository._format),
80
 
               str(self.to_repository), str(self.to_repository._format))
 
78
               self.from_repository, self.from_repository._format,
 
79
               self.to_repository, self.to_repository._format)
81
80
        try:
82
81
            self.__fetch()
83
82
        finally:
97
96
        # assert not missing
98
97
        self.count_total = 0
99
98
        self.file_ids_names = {}
100
 
        with ui.ui_factory.nested_progress_bar() as pb:
101
 
            pb.show_pct = pb.show_count = False
102
 
            pb.update(gettext("Finding revisions"), 0, 2)
103
 
            search_result = self._revids_to_fetch()
104
 
            mutter('fetching: %s', str(search_result))
105
 
            if search_result.is_empty():
 
99
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
100
        pb.show_pct = pb.show_count = False
 
101
        try:
 
102
            pb.update("Finding revisions", 0, 2)
 
103
            search = self._revids_to_fetch()
 
104
            if search is None:
106
105
                return
107
 
            pb.update(gettext("Fetching revisions"), 1, 2)
108
 
            self._fetch_everything_for_search(search_result)
 
106
            pb.update("Fetching revisions", 1, 2)
 
107
            self._fetch_everything_for_search(search)
 
108
        finally:
 
109
            pb.finished()
109
110
 
110
111
    def _fetch_everything_for_search(self, search):
111
112
        """Fetch all data for the given set of revisions."""
122
123
            raise errors.IncompatibleRepositories(
123
124
                self.from_repository, self.to_repository,
124
125
                "different rich-root support")
125
 
        with ui.ui_factory.nested_progress_bar() as pb:
 
126
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
127
        try:
126
128
            pb.update("Get stream source")
127
129
            source = self.from_repository._get_source(
128
130
                self.to_repository._format)
131
133
            pb.update("Inserting stream")
132
134
            resume_tokens, missing_keys = self.sink.insert_stream(
133
135
                stream, from_format, [])
 
136
            if self.to_repository._fallback_repositories:
 
137
                missing_keys.update(
 
138
                    self._parent_inventories(search.get_keys()))
134
139
            if missing_keys:
135
140
                pb.update("Missing keys")
136
141
                stream = source.get_stream_for_missing_keys(missing_keys)
147
152
                        resume_tokens,))
148
153
            pb.update("Finishing stream")
149
154
            self.sink.finished()
 
155
        finally:
 
156
            pb.finished()
150
157
 
151
158
    def _revids_to_fetch(self):
152
159
        """Determines the exact revisions needed from self.from_repository to
153
160
        install self._last_revision in self.to_repository.
154
161
 
155
 
        :returns: A SearchResult of some sort.  (Possibly a
156
 
            PendingAncestryResult, EmptySearchResult, etc.)
 
162
        If no revisions need to be fetched, then this just returns None.
157
163
        """
158
164
        if self._fetch_spec is not None:
159
 
            # The fetch spec is already a concrete search result.
160
165
            return self._fetch_spec
161
 
        elif self._last_revision == NULL_REVISION:
162
 
            # fetch_spec is None + last_revision is null => empty fetch.
 
166
        mutter('fetch up to rev {%s}', self._last_revision)
 
167
        if self._last_revision is NULL_REVISION:
163
168
            # explicit limit of no revisions needed
164
 
            return vf_search.EmptySearchResult()
165
 
        elif self._last_revision is not None:
166
 
            return vf_search.NotInOtherForRevs(self.to_repository,
167
 
                self.from_repository, [self._last_revision],
168
 
                find_ghosts=self.find_ghosts).execute()
169
 
        else: # self._last_revision is None:
170
 
            return vf_search.EverythingNotInOther(self.to_repository,
171
 
                self.from_repository,
172
 
                find_ghosts=self.find_ghosts).execute()
 
169
            return None
 
170
        return self.to_repository.search_missing_revision_ids(
 
171
            self.from_repository, self._last_revision,
 
172
            find_ghosts=self.find_ghosts)
 
173
 
 
174
    def _parent_inventories(self, revision_ids):
 
175
        # Find all the parent revisions referenced by the stream, but
 
176
        # not present in the stream, and make sure we send their
 
177
        # inventories.
 
178
        parent_maps = self.to_repository.get_parent_map(revision_ids)
 
179
        parents = set()
 
180
        map(parents.update, parent_maps.itervalues())
 
181
        parents.discard(NULL_REVISION)
 
182
        parents.difference_update(revision_ids)
 
183
        missing_keys = set(('inventories', rev_id) for rev_id in parents)
 
184
        return missing_keys
173
185
 
174
186
 
175
187
class Inter1and2Helper(object):
178
190
    This is for use by fetchers and converters.
179
191
    """
180
192
 
181
 
    # This is a class variable so that the test suite can override it.
182
 
    known_graph_threshold = 100
183
 
 
184
193
    def __init__(self, source):
185
194
        """Constructor.
186
195
 
202
211
        revs = list(revs)
203
212
        while revs:
204
213
            for tree in self.source.revision_trees(revs[:100]):
205
 
                if tree.root_inventory.revision_id is None:
206
 
                    tree.root_inventory.revision_id = tree.get_revision_id()
 
214
                if tree.inventory.revision_id is None:
 
215
                    tree.inventory.revision_id = tree.get_revision_id()
207
216
                yield tree
208
217
            revs = revs[100:]
209
218
 
210
219
    def _find_root_ids(self, revs, parent_map, graph):
211
220
        revision_root = {}
212
221
        for tree in self.iter_rev_trees(revs):
 
222
            revision_id = tree.inventory.root.revision
213
223
            root_id = tree.get_root_id()
214
 
            revision_id = tree.get_file_revision(u'', root_id)
215
224
            revision_root[revision_id] = root_id
216
225
        # Find out which parents we don't already know root ids for
217
 
        parents = set(viewvalues(parent_map))
218
 
        parents.difference_update(revision_root)
219
 
        parents.discard(NULL_REVISION)
 
226
        parents = set()
 
227
        for revision_parents in parent_map.itervalues():
 
228
            parents.update(revision_parents)
 
229
        parents.difference_update(revision_root.keys() + [NULL_REVISION])
220
230
        # Limit to revisions present in the versionedfile
221
 
        parents = graph.get_parent_map(parents)
 
231
        parents = graph.get_parent_map(parents).keys()
222
232
        for tree in self.iter_rev_trees(parents):
223
233
            root_id = tree.get_root_id()
224
234
            revision_root[tree.get_revision_id()] = root_id
241
251
        # yet, and are unlikely to in non-rich-root environments anyway.
242
252
        root_id_order.sort(key=operator.itemgetter(0))
243
253
        # Create a record stream containing the roots to create.
244
 
        if len(revs) > self.known_graph_threshold:
245
 
            graph = self.source.get_known_graph_ancestry(revs)
 
254
        from bzrlib.graph import FrozenHeadsCache
 
255
        graph = FrozenHeadsCache(graph)
246
256
        new_roots_stream = _new_root_data_stream(
247
257
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
248
258
        return [('texts', new_roots_stream)]
268
278
        parent_keys = _parent_keys_for_root_version(
269
279
            root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph)
270
280
        yield versionedfile.FulltextContentFactory(
271
 
            root_key, parent_keys, None, b'')
 
281
            root_key, parent_keys, None, '')
272
282
 
273
283
 
274
284
def _parent_keys_for_root_version(
317
327
                pass
318
328
            else:
319
329
                try:
320
 
                    parent_ids.append(tree.get_file_revision(tree.id2path(root_id), root_id))
 
330
                    parent_ids.append(tree.inventory[root_id].revision)
321
331
                except errors.NoSuchId:
322
332
                    # not in the tree
323
333
                    pass
331
341
            selected_ids.append(parent_id)
332
342
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
333
343
    return parent_keys
334
 
 
335
 
 
336
 
class TargetRepoKinds(object):
337
 
    """An enum-like set of constants.
338
 
    
339
 
    They are the possible values of FetchSpecFactory.target_repo_kinds.
340
 
    """
341
 
    
342
 
    PREEXISTING = 'preexisting'
343
 
    STACKED = 'stacked'
344
 
    EMPTY = 'empty'
345
 
 
346
 
 
347
 
class FetchSpecFactory(object):
348
 
    """A helper for building the best fetch spec for a sprout call.
349
 
 
350
 
    Factors that go into determining the sort of fetch to perform:
351
 
     * did the caller specify any revision IDs?
352
 
     * did the caller specify a source branch (need to fetch its
353
 
       heads_to_fetch(), usually the tip + tags)
354
 
     * is there an existing target repo (don't need to refetch revs it
355
 
       already has)
356
 
     * target is stacked?  (similar to pre-existing target repo: even if
357
 
       the target itself is new don't want to refetch existing revs)
358
 
 
359
 
    :ivar source_branch: the source branch if one specified, else None.
360
 
    :ivar source_branch_stop_revision_id: fetch up to this revision of
361
 
        source_branch, rather than its tip.
362
 
    :ivar source_repo: the source repository if one found, else None.
363
 
    :ivar target_repo: the target repository acquired by sprout.
364
 
    :ivar target_repo_kind: one of the TargetRepoKinds constants.
365
 
    """
366
 
 
367
 
    def __init__(self):
368
 
        self._explicit_rev_ids = set()
369
 
        self.source_branch = None
370
 
        self.source_branch_stop_revision_id = None
371
 
        self.source_repo = None
372
 
        self.target_repo = None
373
 
        self.target_repo_kind = None
374
 
        self.limit = None
375
 
 
376
 
    def add_revision_ids(self, revision_ids):
377
 
        """Add revision_ids to the set of revision_ids to be fetched."""
378
 
        self._explicit_rev_ids.update(revision_ids)
379
 
 
380
 
    def make_fetch_spec(self):
381
 
        """Build a SearchResult or PendingAncestryResult or etc."""
382
 
        if self.target_repo_kind is None or self.source_repo is None:
383
 
            raise AssertionError(
384
 
                'Incomplete FetchSpecFactory: %r' % (self.__dict__,))
385
 
        if len(self._explicit_rev_ids) == 0 and self.source_branch is None:
386
 
            if self.limit is not None:
387
 
                raise NotImplementedError(
388
 
                    "limit is only supported with a source branch set")
389
 
            # Caller hasn't specified any revisions or source branch
390
 
            if self.target_repo_kind == TargetRepoKinds.EMPTY:
391
 
                return vf_search.EverythingResult(self.source_repo)
392
 
            else:
393
 
                # We want everything not already in the target (or target's
394
 
                # fallbacks).
395
 
                return vf_search.EverythingNotInOther(
396
 
                    self.target_repo, self.source_repo).execute()
397
 
        heads_to_fetch = set(self._explicit_rev_ids)
398
 
        if self.source_branch is not None:
399
 
            must_fetch, if_present_fetch = self.source_branch.heads_to_fetch()
400
 
            if self.source_branch_stop_revision_id is not None:
401
 
                # Replace the tip rev from must_fetch with the stop revision
402
 
                # XXX: this might be wrong if the tip rev is also in the
403
 
                # must_fetch set for other reasons (e.g. it's the tip of
404
 
                # multiple loom threads?), but then it's pretty unclear what it
405
 
                # should mean to specify a stop_revision in that case anyway.
406
 
                must_fetch.discard(self.source_branch.last_revision())
407
 
                must_fetch.add(self.source_branch_stop_revision_id)
408
 
            heads_to_fetch.update(must_fetch)
409
 
        else:
410
 
            if_present_fetch = set()
411
 
        if self.target_repo_kind == TargetRepoKinds.EMPTY:
412
 
            # PendingAncestryResult does not raise errors if a requested head
413
 
            # is absent.  Ideally it would support the
414
 
            # required_ids/if_present_ids distinction, but in practice
415
 
            # heads_to_fetch will almost certainly be present so this doesn't
416
 
            # matter much.
417
 
            all_heads = heads_to_fetch.union(if_present_fetch)
418
 
            ret = vf_search.PendingAncestryResult(all_heads, self.source_repo)
419
 
            if self.limit is not None:
420
 
                graph = self.source_repo.get_graph()
421
 
                topo_order = list(graph.iter_topo_order(ret.get_keys()))
422
 
                result_set = topo_order[:self.limit]
423
 
                ret = self.source_repo.revision_ids_to_search_result(result_set)
424
 
            return ret
425
 
        else:
426
 
            return vf_search.NotInOtherForRevs(self.target_repo, self.source_repo,
427
 
                required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
428
 
                limit=self.limit).execute()