/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: Martin Pool
  • Date: 2009-07-27 06:28:35 UTC
  • mto: This revision was merged to the branch mainline in revision 4587.
  • Revision ID: mbp@sourcefrog.net-20090727062835-o66p8it658tq1sma
Add CountedLock.get_physical_lock_status

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
30
 
lazy_import(globals(), """
31
 
from breezy import (
32
 
    tsort,
33
 
    )
34
 
from breezy.bzr import (
35
 
    versionedfile,
36
 
    vf_search,
37
 
    )
38
 
""")
39
 
from .. import (
 
28
import bzrlib
 
29
from bzrlib import (
40
30
    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
 
31
    symbol_versioning,
 
32
    )
 
33
from bzrlib.revision import NULL_REVISION
 
34
from bzrlib.tsort import topo_sort
 
35
from bzrlib.trace import mutter
 
36
import bzrlib.ui
 
37
from bzrlib.versionedfile import FulltextContentFactory
49
38
 
50
39
 
51
40
class RepoFetcher(object):
56
45
    """
57
46
 
58
47
    def __init__(self, to_repository, from_repository, last_revision=None,
59
 
                 find_ghosts=True, fetch_spec=None):
 
48
        pb=None, find_ghosts=True, fetch_spec=None):
60
49
        """Create a repo fetcher.
61
50
 
62
51
        :param last_revision: If set, try to limit to the data this revision
63
52
            references.
64
 
        :param fetch_spec: A SearchResult specifying which revisions to fetch.
65
 
            If set, this overrides last_revision.
66
53
        :param find_ghosts: If True search the entire history for ghosts.
 
54
        :param pb: ProgressBar object to use; deprecated and ignored.
 
55
            This method will just create one on top of the stack.
67
56
        """
 
57
        if pb is not None:
 
58
            symbol_versioning.warn(
 
59
                symbol_versioning.deprecated_in((1, 14, 0))
 
60
                % "pb parameter to RepoFetcher.__init__")
 
61
            # and for simplicity it is in fact ignored
68
62
        # repository.fetch has the responsibility for short-circuiting
69
63
        # attempts to copy between a repository and itself.
70
64
        self.to_repository = to_repository
74
68
        self._last_revision = last_revision
75
69
        self._fetch_spec = fetch_spec
76
70
        self.find_ghosts = find_ghosts
77
 
        with self.from_repository.lock_read():
78
 
            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))
 
71
        self.from_repository.lock_read()
 
72
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
73
               self.from_repository, self.from_repository._format,
 
74
               self.to_repository, self.to_repository._format)
 
75
        try:
81
76
            self.__fetch()
 
77
        finally:
 
78
            self.from_repository.unlock()
82
79
 
83
80
    def __fetch(self):
84
81
        """Primary worker function.
94
91
        # assert not missing
95
92
        self.count_total = 0
96
93
        self.file_ids_names = {}
97
 
        with ui.ui_factory.nested_progress_bar() as pb:
98
 
            pb.show_pct = pb.show_count = False
99
 
            pb.update(gettext("Finding revisions"), 0, 2)
100
 
            search_result = self._revids_to_fetch()
101
 
            mutter('fetching: %s', str(search_result))
102
 
            if search_result.is_empty():
 
94
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
95
        pb.show_pct = pb.show_count = False
 
96
        try:
 
97
            pb.update("Finding revisions", 0, 2)
 
98
            search = self._revids_to_fetch()
 
99
            if search is None:
103
100
                return
104
 
            pb.update(gettext("Fetching revisions"), 1, 2)
105
 
            self._fetch_everything_for_search(search_result)
 
101
            pb.update("Fetching revisions", 1, 2)
 
102
            self._fetch_everything_for_search(search)
 
103
        finally:
 
104
            pb.finished()
106
105
 
107
106
    def _fetch_everything_for_search(self, search):
108
107
        """Fetch all data for the given set of revisions."""
115
114
        # moment, so that it can feed the progress information back to this
116
115
        # function?
117
116
        if (self.from_repository._format.rich_root_data and
118
 
                not self.to_repository._format.rich_root_data):
 
117
            not self.to_repository._format.rich_root_data):
119
118
            raise errors.IncompatibleRepositories(
120
119
                self.from_repository, self.to_repository,
121
120
                "different rich-root support")
122
 
        with ui.ui_factory.nested_progress_bar() as pb:
 
121
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
122
        try:
123
123
            pb.update("Get stream source")
124
124
            source = self.from_repository._get_source(
125
125
                self.to_repository._format)
128
128
            pb.update("Inserting stream")
129
129
            resume_tokens, missing_keys = self.sink.insert_stream(
130
130
                stream, from_format, [])
 
131
            if self.to_repository._fallback_repositories:
 
132
                missing_keys.update(
 
133
                    self._parent_inventories(search.get_keys()))
131
134
            if missing_keys:
132
135
                pb.update("Missing keys")
133
136
                stream = source.get_stream_for_missing_keys(missing_keys)
144
147
                        resume_tokens,))
145
148
            pb.update("Finishing stream")
146
149
            self.sink.finished()
 
150
        finally:
 
151
            pb.finished()
147
152
 
148
153
    def _revids_to_fetch(self):
149
154
        """Determines the exact revisions needed from self.from_repository to
150
155
        install self._last_revision in self.to_repository.
151
156
 
152
 
        :returns: A SearchResult of some sort.  (Possibly a
153
 
            PendingAncestryResult, EmptySearchResult, etc.)
 
157
        If no revisions need to be fetched, then this just returns None.
154
158
        """
155
159
        if self._fetch_spec is not None:
156
 
            # The fetch spec is already a concrete search result.
157
160
            return self._fetch_spec
158
 
        elif self._last_revision == NULL_REVISION:
159
 
            # fetch_spec is None + last_revision is null => empty fetch.
 
161
        mutter('fetch up to rev {%s}', self._last_revision)
 
162
        if self._last_revision is NULL_REVISION:
160
163
            # explicit limit of no revisions needed
161
 
            return vf_search.EmptySearchResult()
162
 
        elif self._last_revision is not None:
163
 
            return vf_search.NotInOtherForRevs(self.to_repository,
164
 
                                               self.from_repository, [
165
 
                                                   self._last_revision],
166
 
                                               find_ghosts=self.find_ghosts).execute()
167
 
        else:  # self._last_revision is None:
168
 
            return vf_search.EverythingNotInOther(self.to_repository,
169
 
                                                  self.from_repository,
170
 
                                                  find_ghosts=self.find_ghosts).execute()
 
164
            return None
 
165
        return self.to_repository.search_missing_revision_ids(
 
166
            self.from_repository, self._last_revision,
 
167
            find_ghosts=self.find_ghosts)
 
168
 
 
169
    def _parent_inventories(self, revision_ids):
 
170
        # Find all the parent revisions referenced by the stream, but
 
171
        # not present in the stream, and make sure we send their
 
172
        # inventories.
 
173
        parent_maps = self.to_repository.get_parent_map(revision_ids)
 
174
        parents = set()
 
175
        map(parents.update, parent_maps.itervalues())
 
176
        parents.discard(NULL_REVISION)
 
177
        parents.difference_update(revision_ids)
 
178
        missing_keys = set(('inventories', rev_id) for rev_id in parents)
 
179
        return missing_keys
171
180
 
172
181
 
173
182
class Inter1and2Helper(object):
176
185
    This is for use by fetchers and converters.
177
186
    """
178
187
 
179
 
    # This is a class variable so that the test suite can override it.
180
 
    known_graph_threshold = 100
181
 
 
182
188
    def __init__(self, source):
183
189
        """Constructor.
184
190
 
200
206
        revs = list(revs)
201
207
        while revs:
202
208
            for tree in self.source.revision_trees(revs[:100]):
203
 
                if tree.root_inventory.revision_id is None:
204
 
                    tree.root_inventory.revision_id = tree.get_revision_id()
 
209
                if tree.inventory.revision_id is None:
 
210
                    tree.inventory.revision_id = tree.get_revision_id()
205
211
                yield tree
206
212
            revs = revs[100:]
207
213
 
208
214
    def _find_root_ids(self, revs, parent_map, graph):
209
215
        revision_root = {}
 
216
        planned_versions = {}
210
217
        for tree in self.iter_rev_trees(revs):
211
 
            root_id = tree.path2id('')
212
 
            revision_id = tree.get_file_revision(u'')
 
218
            revision_id = tree.inventory.root.revision
 
219
            root_id = tree.get_root_id()
 
220
            planned_versions.setdefault(root_id, []).append(revision_id)
213
221
            revision_root[revision_id] = root_id
214
222
        # Find out which parents we don't already know root ids for
215
 
        parents = set(viewvalues(parent_map))
216
 
        parents.difference_update(revision_root)
217
 
        parents.discard(NULL_REVISION)
 
223
        parents = set()
 
224
        for revision_parents in parent_map.itervalues():
 
225
            parents.update(revision_parents)
 
226
        parents.difference_update(revision_root.keys() + [NULL_REVISION])
218
227
        # Limit to revisions present in the versionedfile
219
 
        parents = graph.get_parent_map(parents)
 
228
        parents = graph.get_parent_map(parents).keys()
220
229
        for tree in self.iter_rev_trees(parents):
221
 
            root_id = tree.path2id('')
 
230
            root_id = tree.get_root_id()
222
231
            revision_root[tree.get_revision_id()] = root_id
223
 
        return revision_root
 
232
        return revision_root, planned_versions
224
233
 
225
234
    def generate_root_texts(self, revs):
226
235
        """Generate VersionedFiles for all root ids.
229
238
        """
230
239
        graph = self.source.get_graph()
231
240
        parent_map = graph.get_parent_map(revs)
232
 
        rev_order = tsort.topo_sort(parent_map)
233
 
        rev_id_to_root_id = self._find_root_ids(revs, parent_map, graph)
 
241
        rev_order = topo_sort(parent_map)
 
242
        rev_id_to_root_id, root_id_to_rev_ids = self._find_root_ids(
 
243
            revs, parent_map, graph)
234
244
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
235
 
                         rev_order]
 
245
            rev_order]
236
246
        # Guaranteed stable, this groups all the file id operations together
237
247
        # retaining topological order within the revisions of a file id.
238
248
        # File id splits and joins would invalidate this, but they don't exist
239
249
        # yet, and are unlikely to in non-rich-root environments anyway.
240
250
        root_id_order.sort(key=operator.itemgetter(0))
241
251
        # Create a record stream containing the roots to create.
242
 
        if len(revs) > self.known_graph_threshold:
243
 
            graph = self.source.get_known_graph_ancestry(revs)
244
 
        new_roots_stream = _new_root_data_stream(
245
 
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
246
 
        return [('texts', new_roots_stream)]
247
 
 
248
 
 
249
 
def _new_root_data_stream(
250
 
        root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
251
 
    """Generate a texts substream of synthesised root entries.
252
 
 
253
 
    Used in fetches that do rich-root upgrades.
254
 
 
255
 
    :param root_keys_to_create: iterable of (root_id, rev_id) pairs describing
256
 
        the root entries to create.
257
 
    :param rev_id_to_root_id_map: dict of known rev_id -> root_id mappings for
258
 
        calculating the parents.  If a parent rev_id is not found here then it
259
 
        will be recalculated.
260
 
    :param parent_map: a parent map for all the revisions in
261
 
        root_keys_to_create.
262
 
    :param graph: a graph to use instead of repo.get_graph().
263
 
    """
264
 
    for root_key in root_keys_to_create:
265
 
        root_id, rev_id = root_key
266
 
        parent_keys = _parent_keys_for_root_version(
267
 
            root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph)
268
 
        yield versionedfile.ChunkedContentFactory(
269
 
            root_key, parent_keys, None, [])
270
 
 
271
 
 
272
 
def _parent_keys_for_root_version(
273
 
        root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
274
 
    """Get the parent keys for a given root id.
275
 
 
276
 
    A helper function for _new_root_data_stream.
277
 
    """
278
 
    # Include direct parents of the revision, but only if they used the same
279
 
    # root_id and are heads.
280
 
    rev_parents = parent_map[rev_id]
281
 
    parent_ids = []
282
 
    for parent_id in rev_parents:
283
 
        if parent_id == NULL_REVISION:
284
 
            continue
285
 
        if parent_id not in rev_id_to_root_id_map:
286
 
            # We probably didn't read this revision, go spend the extra effort
287
 
            # to actually check
288
 
            try:
289
 
                tree = repo.revision_tree(parent_id)
290
 
            except errors.NoSuchRevision:
291
 
                # Ghost, fill out rev_id_to_root_id in case we encounter this
292
 
                # again.
293
 
                # But set parent_root_id to None since we don't really know
294
 
                parent_root_id = None
295
 
            else:
296
 
                parent_root_id = tree.path2id('')
297
 
            rev_id_to_root_id_map[parent_id] = None
298
 
            # XXX: why not:
299
 
            #   rev_id_to_root_id_map[parent_id] = parent_root_id
300
 
            # memory consumption maybe?
301
 
        else:
302
 
            parent_root_id = rev_id_to_root_id_map[parent_id]
303
 
        if root_id == parent_root_id:
304
 
            # With stacking we _might_ want to refer to a non-local revision,
305
 
            # but this code path only applies when we have the full content
306
 
            # available, so ghosts really are ghosts, not just the edge of
307
 
            # local data.
308
 
            parent_ids.append(parent_id)
309
 
        else:
310
 
            # root_id may be in the parent anyway.
311
 
            try:
312
 
                tree = repo.revision_tree(parent_id)
313
 
            except errors.NoSuchRevision:
314
 
                # ghost, can't refer to it.
315
 
                pass
316
 
            else:
317
 
                try:
318
 
                    parent_ids.append(
319
 
                        tree.get_file_revision(
320
 
                            tree.id2path(root_id, recurse='none')))
321
 
                except errors.NoSuchId:
322
 
                    # not in the tree
323
 
                    pass
324
 
    # Drop non-head parents
325
 
    if graph is None:
326
 
        graph = repo.get_graph()
327
 
    heads = graph.heads(parent_ids)
328
 
    selected_ids = []
329
 
    for parent_id in parent_ids:
330
 
        if parent_id in heads and parent_id not in selected_ids:
331
 
            selected_ids.append(parent_id)
332
 
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
333
 
    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(
424
 
                    result_set)
425
 
            return ret
426
 
        else:
427
 
            return vf_search.NotInOtherForRevs(self.target_repo, self.source_repo,
428
 
                                               required_ids=heads_to_fetch, if_present_ids=if_present_fetch,
429
 
                                               limit=self.limit).execute()
 
252
        def yield_roots():
 
253
            for key in root_id_order:
 
254
                root_id, rev_id = key
 
255
                rev_parents = parent_map[rev_id]
 
256
                # We drop revision parents with different file-ids, because
 
257
                # that represents a rename of the root to a different location
 
258
                # - its not actually a parent for us. (We could look for that
 
259
                # file id in the revision tree at considerably more expense,
 
260
                # but for now this is sufficient (and reconcile will catch and
 
261
                # correct this anyway).
 
262
                # When a parent revision is a ghost, we guess that its root id
 
263
                # was unchanged (rather than trimming it from the parent list).
 
264
                parent_keys = tuple((root_id, parent) for parent in rev_parents
 
265
                    if parent != NULL_REVISION and
 
266
                        rev_id_to_root_id.get(parent, root_id) == root_id)
 
267
                yield FulltextContentFactory(key, parent_keys, None, '')
 
268
        return [('texts', yield_roots())]