← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/fetch.py

  • Committer: Vincent Ladeuil
  • Date: 2009-04-27 16:10:10 UTC
  • mto: (4310.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4311.
  • Revision ID: v.ladeuil+lp@free.fr-20090427161010-7swfzeagf63cpixd
Fix bug #367726 by reverting some default user handling introduced
while fixing bug #256612.

* bzrlib/transport/ssh.py:
(_paramiko_auth): Explicitly use getpass.getuser() as default
user.

* bzrlib/transport/ftp/_gssapi.py:
(GSSAPIFtpTransport._create_connection): Explicitly use
getpass.getuser() as default user.

* bzrlib/transport/ftp/__init__.py:
(FtpTransport._create_connection): Explicitly use
getpass.getuser() as default user.

* bzrlib/tests/test_sftp_transport.py:
(TestUsesAuthConfig.test_sftp_is_none_if_no_config)
(TestUsesAuthConfig.test_sftp_doesnt_prompt_username): Revert to
None as the default user.

* bzrlib/tests/test_remote.py:
(TestRemoteSSHTransportAuthentication): The really offending one:
revert to None as the default user.

* bzrlib/tests/test_config.py:
(TestAuthenticationConfig.test_username_default_no_prompt): Update
test (and some PEP8).

* bzrlib/smtp_connection.py:
(SMTPConnection._authenticate): Revert to None as the default
user.

* bzrlib/plugins/launchpad/account.py:
(_get_auth_user): Revert default value handling.

* bzrlib/config.py:
(AuthenticationConfig.get_user): Fix doc-string. Leave default
value handling to callers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/fetch.py
1
 
# Copyright (C) 2005-2010 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
25
25
 
26
26
import operator
27
27
 
28
 
from bzrlib.lazy_import import lazy_import
29
 
lazy_import(globals(), """
30
 
from bzrlib import (
31
 
    tsort,
32
 
    versionedfile,
33
 
    )
34
 
""")
35
28
import bzrlib
36
29
from bzrlib import (
37
30
    errors,
38
 
    ui,
 
31
    symbol_versioning,
39
32
    )
 
33
from bzrlib.errors import InstallFailed
 
34
from bzrlib.progress import ProgressPhase
40
35
from bzrlib.revision import NULL_REVISION
 
36
from bzrlib.tsort import topo_sort
41
37
from bzrlib.trace import mutter
 
38
import bzrlib.ui
 
39
from bzrlib.versionedfile import FulltextContentFactory
42
40
 
43
41
 
44
42
class RepoFetcher(object):
49
47
    """
50
48
 
51
49
    def __init__(self, to_repository, from_repository, last_revision=None,
52
 
        find_ghosts=True, fetch_spec=None):
 
50
        pb=None, find_ghosts=True, fetch_spec=None):
53
51
        """Create a repo fetcher.
54
52
 
55
53
        :param last_revision: If set, try to limit to the data this revision
56
54
            references.
57
55
        :param find_ghosts: If True search the entire history for ghosts.
 
56
        :param _write_group_acquired_callable: Don't use; this parameter only
 
57
            exists to facilitate a hack done in InterPackRepo.fetch.  We would
 
58
            like to remove this parameter.
 
59
        :param pb: ProgressBar object to use; deprecated and ignored.
 
60
            This method will just create one on top of the stack.
58
61
        """
59
 
        # repository.fetch has the responsibility for short-circuiting
60
 
        # attempts to copy between a repository and itself.
 
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
 
67
        if to_repository.has_same_location(from_repository):
 
68
            # repository.fetch should be taking care of this case.
 
69
            raise errors.BzrError('RepoFetcher run '
 
70
                    'between two objects at the same location: '
 
71
                    '%r and %r' % (to_repository, from_repository))
61
72
        self.to_repository = to_repository
62
73
        self.from_repository = from_repository
63
74
        self.sink = to_repository._get_sink()
88
99
        # assert not missing
89
100
        self.count_total = 0
90
101
        self.file_ids_names = {}
91
 
        pb = ui.ui_factory.nested_progress_bar()
 
102
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
92
103
        pb.show_pct = pb.show_count = False
93
104
        try:
94
105
            pb.update("Finding revisions", 0, 2)
115
126
            raise errors.IncompatibleRepositories(
116
127
                self.from_repository, self.to_repository,
117
128
                "different rich-root support")
118
 
        pb = ui.ui_factory.nested_progress_bar()
 
129
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
119
130
        try:
120
131
            pb.update("Get stream source")
121
132
            source = self.from_repository._get_source(
126
137
            resume_tokens, missing_keys = self.sink.insert_stream(
127
138
                stream, from_format, [])
128
139
            if self.to_repository._fallback_repositories:
 
140
                # Find all the parent revisions referenced by the stream, but
 
141
                # not present in the stream, and make sure we have their
 
142
                # inventories.
 
143
                revision_ids = search.get_keys()
 
144
                parent_maps = self.to_repository.get_parent_map(revision_ids)
 
145
                parents = set()
 
146
                map(parents.update, parent_maps.itervalues())
 
147
                parents.difference_update(revision_ids)
 
148
                parents.discard(NULL_REVISION)
129
149
                missing_keys.update(
130
 
                    self._parent_inventories(search.get_keys()))
 
150
                    ('inventories', rev_id) for rev_id in parents)
131
151
            if missing_keys:
132
152
                pb.update("Missing keys")
133
153
                stream = source.get_stream_for_missing_keys(missing_keys)
159
179
        if self._last_revision is NULL_REVISION:
160
180
            # explicit limit of no revisions needed
161
181
            return None
162
 
        return self.to_repository.search_missing_revision_ids(
163
 
            self.from_repository, self._last_revision,
164
 
            find_ghosts=self.find_ghosts)
165
 
 
166
 
    def _parent_inventories(self, revision_ids):
167
 
        # Find all the parent revisions referenced by the stream, but
168
 
        # not present in the stream, and make sure we send their
169
 
        # inventories.
170
 
        parent_maps = self.to_repository.get_parent_map(revision_ids)
171
 
        parents = set()
172
 
        map(parents.update, parent_maps.itervalues())
173
 
        parents.discard(NULL_REVISION)
174
 
        parents.difference_update(revision_ids)
175
 
        missing_keys = set(('inventories', rev_id) for rev_id in parents)
176
 
        return missing_keys
 
182
        if (self._last_revision is not None and
 
183
            self.to_repository.has_revision(self._last_revision)):
 
184
            return None
 
185
        try:
 
186
            return self.to_repository.search_missing_revision_ids(
 
187
                self.from_repository, self._last_revision,
 
188
                find_ghosts=self.find_ghosts)
 
189
        except errors.NoSuchRevision, e:
 
190
            raise InstallFailed([self._last_revision])
177
191
 
178
192
 
179
193
class Inter1and2Helper(object):
182
196
    This is for use by fetchers and converters.
183
197
    """
184
198
 
185
 
    # This is a class variable so that the test suite can override it.
186
 
    known_graph_threshold = 100
187
 
 
188
199
    def __init__(self, source):
189
200
        """Constructor.
190
201
 
213
224
 
214
225
    def _find_root_ids(self, revs, parent_map, graph):
215
226
        revision_root = {}
 
227
        planned_versions = {}
216
228
        for tree in self.iter_rev_trees(revs):
217
229
            revision_id = tree.inventory.root.revision
218
230
            root_id = tree.get_root_id()
 
231
            planned_versions.setdefault(root_id, []).append(revision_id)
219
232
            revision_root[revision_id] = root_id
220
233
        # Find out which parents we don't already know root ids for
221
234
        parents = set()
227
240
        for tree in self.iter_rev_trees(parents):
228
241
            root_id = tree.get_root_id()
229
242
            revision_root[tree.get_revision_id()] = root_id
230
 
        return revision_root
 
243
        return revision_root, planned_versions
231
244
 
232
245
    def generate_root_texts(self, revs):
233
246
        """Generate VersionedFiles for all root ids.
236
249
        """
237
250
        graph = self.source.get_graph()
238
251
        parent_map = graph.get_parent_map(revs)
239
 
        rev_order = tsort.topo_sort(parent_map)
240
 
        rev_id_to_root_id = self._find_root_ids(revs, parent_map, graph)
 
252
        rev_order = topo_sort(parent_map)
 
253
        rev_id_to_root_id, root_id_to_rev_ids = self._find_root_ids(
 
254
            revs, parent_map, graph)
241
255
        root_id_order = [(rev_id_to_root_id[rev_id], rev_id) for rev_id in
242
256
            rev_order]
243
257
        # Guaranteed stable, this groups all the file id operations together
246
260
        # yet, and are unlikely to in non-rich-root environments anyway.
247
261
        root_id_order.sort(key=operator.itemgetter(0))
248
262
        # Create a record stream containing the roots to create.
249
 
        if len(revs) > self.known_graph_threshold:
250
 
            graph = self.source.get_known_graph_ancestry(revs)
251
 
        new_roots_stream = _new_root_data_stream(
252
 
            root_id_order, rev_id_to_root_id, parent_map, self.source, graph)
253
 
        return [('texts', new_roots_stream)]
254
 
 
255
 
 
256
 
def _new_root_data_stream(
257
 
    root_keys_to_create, rev_id_to_root_id_map, parent_map, repo, graph=None):
258
 
    """Generate a texts substream of synthesised root entries.
259
 
 
260
 
    Used in fetches that do rich-root upgrades.
261
 
    
262
 
    :param root_keys_to_create: iterable of (root_id, rev_id) pairs describing
263
 
        the root entries to create.
264
 
    :param rev_id_to_root_id_map: dict of known rev_id -> root_id mappings for
265
 
        calculating the parents.  If a parent rev_id is not found here then it
266
 
        will be recalculated.
267
 
    :param parent_map: a parent map for all the revisions in
268
 
        root_keys_to_create.
269
 
    :param graph: a graph to use instead of repo.get_graph().
270
 
    """
271
 
    for root_key in root_keys_to_create:
272
 
        root_id, rev_id = root_key
273
 
        parent_keys = _parent_keys_for_root_version(
274
 
            root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph)
275
 
        yield versionedfile.FulltextContentFactory(
276
 
            root_key, parent_keys, None, '')
277
 
 
278
 
 
279
 
def _parent_keys_for_root_version(
280
 
    root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph=None):
281
 
    """Get the parent keys for a given root id.
282
 
    
283
 
    A helper function for _new_root_data_stream.
284
 
    """
285
 
    # Include direct parents of the revision, but only if they used the same
286
 
    # root_id and are heads.
287
 
    rev_parents = parent_map[rev_id]
288
 
    parent_ids = []
289
 
    for parent_id in rev_parents:
290
 
        if parent_id == NULL_REVISION:
291
 
            continue
292
 
        if parent_id not in rev_id_to_root_id_map:
293
 
            # We probably didn't read this revision, go spend the extra effort
294
 
            # to actually check
295
 
            try:
296
 
                tree = repo.revision_tree(parent_id)
297
 
            except errors.NoSuchRevision:
298
 
                # Ghost, fill out rev_id_to_root_id in case we encounter this
299
 
                # again.
300
 
                # But set parent_root_id to None since we don't really know
301
 
                parent_root_id = None
302
 
            else:
303
 
                parent_root_id = tree.get_root_id()
304
 
            rev_id_to_root_id_map[parent_id] = None
305
 
            # XXX: why not:
306
 
            #   rev_id_to_root_id_map[parent_id] = parent_root_id
307
 
            # memory consumption maybe?
308
 
        else:
309
 
            parent_root_id = rev_id_to_root_id_map[parent_id]
310
 
        if root_id == parent_root_id:
311
 
            # With stacking we _might_ want to refer to a non-local revision,
312
 
            # but this code path only applies when we have the full content
313
 
            # available, so ghosts really are ghosts, not just the edge of
314
 
            # local data.
315
 
            parent_ids.append(parent_id)
316
 
        else:
317
 
            # root_id may be in the parent anyway.
318
 
            try:
319
 
                tree = repo.revision_tree(parent_id)
320
 
            except errors.NoSuchRevision:
321
 
                # ghost, can't refer to it.
322
 
                pass
323
 
            else:
324
 
                try:
325
 
                    parent_ids.append(tree.inventory[root_id].revision)
326
 
                except errors.NoSuchId:
327
 
                    # not in the tree
328
 
                    pass
329
 
    # Drop non-head parents
330
 
    if graph is None:
331
 
        graph = repo.get_graph()
332
 
    heads = graph.heads(parent_ids)
333
 
    selected_ids = []
334
 
    for parent_id in parent_ids:
335
 
        if parent_id in heads and parent_id not in selected_ids:
336
 
            selected_ids.append(parent_id)
337
 
    parent_keys = [(root_id, parent_id) for parent_id in selected_ids]
338
 
    return parent_keys
 
263
        def yield_roots():
 
264
            for key in root_id_order:
 
265
                root_id, rev_id = key
 
266
                rev_parents = parent_map[rev_id]
 
267
                # We drop revision parents with different file-ids, because
 
268
                # that represents a rename of the root to a different location
 
269
                # - its not actually a parent for us. (We could look for that
 
270
                # file id in the revision tree at considerably more expense,
 
271
                # but for now this is sufficient (and reconcile will catch and
 
272
                # correct this anyway).
 
273
                # When a parent revision is a ghost, we guess that its root id
 
274
                # was unchanged (rather than trimming it from the parent list).
 
275
                parent_keys = tuple((root_id, parent) for parent in rev_parents
 
276
                    if parent != NULL_REVISION and
 
277
                        rev_id_to_root_id.get(parent, root_id) == root_id)
 
278
                yield FulltextContentFactory(key, parent_keys, None, '')
 
279
        return [('texts', yield_roots())]