← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mutabletree.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/mutabletree.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
23
23
from bzrlib.lazy_import import lazy_import
24
24
lazy_import(globals(), """
25
25
import os
26
 
import re
27
26
 
28
27
from bzrlib import (
29
28
    add,
30
29
    bzrdir,
 
30
    hooks,
 
31
    symbol_versioning,
 
32
    )
 
33
from bzrlib.osutils import dirname
 
34
from bzrlib.revisiontree import RevisionTree
 
35
from bzrlib.trace import mutter, warning
 
36
""")
 
37
 
 
38
from bzrlib import (
31
39
    errors,
32
 
    hooks,
33
40
    osutils,
34
 
    revisiontree,
35
 
    inventory,
36
 
    symbol_versioning,
37
 
    trace,
38
41
    tree,
39
42
    )
40
 
""")
41
 
 
42
43
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
44
from bzrlib.osutils import splitpath
43
45
 
44
46
 
45
47
def needs_tree_write_lock(unbound):
127
129
            # generic constraint checks:
128
130
            if self.is_control_filename(f):
129
131
                raise errors.ForbiddenControlFileError(filename=f)
130
 
            fp = osutils.splitpath(f)
 
132
            fp = splitpath(f)
131
133
        # fill out file kinds for all files [not needed when we stop
132
134
        # caring about the instantaneous file kind within a uncommmitted tree
133
135
        #
183
185
               **kwargs):
184
186
        # avoid circular imports
185
187
        from bzrlib import commit
 
188
        if revprops is None:
 
189
            revprops = {}
186
190
        possible_master_transports=[]
187
 
        revprops = commit.Commit.update_revprops(
188
 
                revprops,
189
 
                self.branch,
190
 
                kwargs.pop('authors', None),
191
 
                kwargs.pop('author', None),
 
191
        if not 'branch-nick' in revprops:
 
192
            revprops['branch-nick'] = self.branch._get_nick(
192
193
                kwargs.get('local', False),
193
194
                possible_master_transports)
 
195
        authors = kwargs.pop('authors', None)
 
196
        author = kwargs.pop('author', None)
 
197
        if authors is not None:
 
198
            if author is not None:
 
199
                raise AssertionError('Specifying both author and authors '
 
200
                        'is not allowed. Specify just authors instead')
 
201
            if 'author' in revprops or 'authors' in revprops:
 
202
                # XXX: maybe we should just accept one of them?
 
203
                raise AssertionError('author property given twice')
 
204
            if authors:
 
205
                for individual in authors:
 
206
                    if '\n' in individual:
 
207
                        raise AssertionError('\\n is not a valid character '
 
208
                                'in an author identity')
 
209
                revprops['authors'] = '\n'.join(authors)
 
210
        if author is not None:
 
211
            symbol_versioning.warn('The parameter author was deprecated'
 
212
                   ' in version 1.13. Use authors instead',
 
213
                   DeprecationWarning)
 
214
            if 'author' in revprops or 'authors' in revprops:
 
215
                # XXX: maybe we should just accept one of them?
 
216
                raise AssertionError('author property given twice')
 
217
            if '\n' in author:
 
218
                raise AssertionError('\\n is not a valid character '
 
219
                        'in an author identity')
 
220
            revprops['authors'] = author
194
221
        # args for wt.commit start at message from the Commit.commit method,
195
222
        args = (message, ) + args
196
223
        for hook in MutableTree.hooks['start_commit']:
199
226
            revprops=revprops,
200
227
            possible_master_transports=possible_master_transports,
201
228
            *args, **kwargs)
202
 
        post_hook_params = PostCommitHookParams(self)
203
 
        for hook in MutableTree.hooks['post_commit']:
204
 
            hook(post_hook_params)
205
229
        return committed_id
206
230
 
207
231
    def _gather_kinds(self, files, kinds):
208
232
        """Helper function for add - sets the entries of kinds."""
209
233
        raise NotImplementedError(self._gather_kinds)
210
234
 
211
 
    @needs_read_lock
212
 
    def has_changes(self, _from_tree=None):
213
 
        """Quickly check that the tree contains at least one commitable change.
214
 
 
215
 
        :param _from_tree: tree to compare against to find changes (default to
216
 
            the basis tree and is intended to be used by tests).
217
 
 
218
 
        :return: True if a change is found. False otherwise
219
 
        """
220
 
        # Check pending merges
221
 
        if len(self.get_parent_ids()) > 1:
222
 
            return True
223
 
        if _from_tree is None:
224
 
            _from_tree = self.basis_tree()
225
 
        changes = self.iter_changes(_from_tree)
226
 
        try:
227
 
            change = changes.next()
228
 
            # Exclude root (talk about black magic... --vila 20090629)
229
 
            if change[4] == (None, None):
230
 
                change = changes.next()
231
 
            return True
232
 
        except StopIteration:
233
 
            # No changes
234
 
            return False
235
 
 
236
 
    @needs_read_lock
237
 
    def check_changed_or_out_of_date(self, strict, opt_name,
238
 
                                     more_error, more_warning):
239
 
        """Check the tree for uncommitted changes and branch synchronization.
240
 
 
241
 
        If strict is None and not set in the config files, a warning is issued.
242
 
        If strict is True, an error is raised.
243
 
        If strict is False, no checks are done and no warning is issued.
244
 
 
245
 
        :param strict: True, False or None, searched in branch config if None.
246
 
 
247
 
        :param opt_name: strict option name to search in config file.
248
 
 
249
 
        :param more_error: Details about how to avoid the check.
250
 
 
251
 
        :param more_warning: Details about what is happening.
252
 
        """
253
 
        if strict is None:
254
 
            strict = self.branch.get_config().get_user_option_as_bool(opt_name)
255
 
        if strict is not False:
256
 
            err_class = None
257
 
            if (self.has_changes()):
258
 
                err_class = errors.UncommittedChanges
259
 
            elif self.last_revision() != self.branch.last_revision():
260
 
                # The tree has lost sync with its branch, there is little
261
 
                # chance that the user is aware of it but he can still force
262
 
                # the action with --no-strict
263
 
                err_class = errors.OutOfDateTree
264
 
            if err_class is not None:
265
 
                if strict is None:
266
 
                    err = err_class(self, more=more_warning)
267
 
                    # We don't want to interrupt the user if he expressed no
268
 
                    # preference about strict.
269
 
                    trace.warning('%s', err._format())
270
 
                else:
271
 
                    err = err_class(self, more=more_error)
272
 
                    raise err
 
235
    def get_file_with_stat(self, file_id, path=None):
 
236
        """Get a file handle and stat object for file_id.
 
237
 
 
238
        The default implementation returns (self.get_file, None) for backwards
 
239
        compatibility.
 
240
 
 
241
        :param file_id: The file id to read.
 
242
        :param path: The path of the file, if it is known.
 
243
        :return: A tuple (file_handle, stat_value_or_None). If the tree has
 
244
            no stat facility, or need for a stat cache feedback during commit,
 
245
            it may return None for the second element of the tuple.
 
246
        """
 
247
        return (self.get_file(file_id, path), None)
273
248
 
274
249
    @needs_read_lock
275
250
    def last_revision(self):
376
351
        This is designed more towards DWIM for humans than API clarity.
377
352
        For the specific behaviour see the help for cmd_add().
378
353
 
379
 
        :param file_list: List of zero or more paths.  *NB: these are 
380
 
            interpreted relative to the process cwd, not relative to the 
381
 
            tree.*  (Add and most other tree methods use tree-relative
382
 
            paths.)
383
354
        :param action: A reporter to be called with the inventory, parent_ie,
384
355
            path and kind of the path being added. It may return a file_id if
385
356
            a specific one should be used.
398
369
 
399
370
        if not file_list:
400
371
            # no paths supplied: add the entire tree.
401
 
            # FIXME: this assumes we are running in a working tree subdir :-/
402
 
            # -- vila 20100208
403
372
            file_list = [u'.']
404
373
        # mutter("smart add of %r")
405
374
        inv = self.inventory
407
376
        ignored = {}
408
377
        dirs_to_add = []
409
378
        user_dirs = set()
410
 
        conflicts_related = set()
411
 
        # Not all mutable trees can have conflicts
412
 
        if getattr(self, 'conflicts', None) is not None:
413
 
            # Collect all related files without checking whether they exist or
414
 
            # are versioned. It's cheaper to do that once for all conflicts
415
 
            # than trying to find the relevant conflict for each added file.
416
 
            for c in self.conflicts():
417
 
                conflicts_related.update(c.associated_filenames())
418
 
 
419
 
        # expand any symlinks in the directory part, while leaving the
420
 
        # filename alone
421
 
        file_list = map(osutils.normalizepath, file_list)
422
379
 
423
380
        # validate user file paths and convert all paths to tree
424
381
        # relative : it's cheaper to make a tree relative path an abspath
426
383
        # perform the canonicalization in bulk.
427
384
        for filepath in osutils.canonical_relpaths(self.basedir, file_list):
428
385
            rf = _FastPath(filepath)
429
 
            # validate user parameters. Our recursive code avoids adding new
430
 
            # files that need such validation
 
386
            # validate user parameters. Our recursive code avoids adding new files
 
387
            # that need such validation
431
388
            if self.is_control_filename(rf.raw_path):
432
389
                raise errors.ForbiddenControlFileError(filename=rf.raw_path)
433
390
 
439
396
            else:
440
397
                if not InventoryEntry.versionable_kind(kind):
441
398
                    raise errors.BadFileKindError(filename=abspath, kind=kind)
442
 
            # ensure the named path is added, so that ignore rules in the later
443
 
            # directory walk dont skip it.
444
 
            # we dont have a parent ie known yet.: use the relatively slower
445
 
            # inventory probing method
 
399
            # ensure the named path is added, so that ignore rules in the later directory
 
400
            # walk dont skip it.
 
401
            # we dont have a parent ie known yet.: use the relatively slower inventory
 
402
            # probing method
446
403
            versioned = inv.has_filename(rf.raw_path)
447
404
            if versioned:
448
405
                continue
464
421
                dirs_to_add.append((path, None))
465
422
            prev_dir = path.raw_path
466
423
 
467
 
        illegalpath_re = re.compile(r'[\r\n]')
468
424
        # dirs_to_add is initialised to a list of directories, but as we scan
469
425
        # directories we append files to it.
470
426
        # XXX: We should determine kind of files when we scan them rather than
479
435
            kind = osutils.file_kind(abspath)
480
436
 
481
437
            if not InventoryEntry.versionable_kind(kind):
482
 
                trace.warning("skipping %s (can't add file of kind '%s')",
483
 
                              abspath, kind)
484
 
                continue
485
 
            if illegalpath_re.search(directory.raw_path):
486
 
                trace.warning("skipping %r (contains \\n or \\r)" % abspath)
487
 
                continue
488
 
            if directory.raw_path in conflicts_related:
489
 
                # If the file looks like one generated for a conflict, don't
490
 
                # add it.
491
 
                trace.warning(
492
 
                    'skipping %s (generated to help resolve conflicts)',
493
 
                    abspath)
 
438
                warning("skipping %s (can't add file of kind '%s')", abspath, kind)
494
439
                continue
495
440
 
496
441
            if parent_ie is not None:
519
464
                pass
520
465
                # mutter("%r is already versioned", abspath)
521
466
            elif sub_tree:
522
 
                # XXX: This is wrong; people *might* reasonably be trying to
523
 
                # add subtrees as subtrees.  This should probably only be done
524
 
                # in formats which can represent subtrees, and even then
525
 
                # perhaps only when the user asked to add subtrees.  At the
526
 
                # moment you can add them specially through 'join --reference',
527
 
                # which is perhaps reasonable: adding a new reference is a
528
 
                # special operation and can have a special behaviour.  mbp
529
 
                # 20070306
530
 
                trace.mutter("%r is a nested bzr tree", abspath)
 
467
                # XXX: This is wrong; people *might* reasonably be trying to add
 
468
                # subtrees as subtrees.  This should probably only be done in formats
 
469
                # which can represent subtrees, and even then perhaps only when
 
470
                # the user asked to add subtrees.  At the moment you can add them
 
471
                # specially through 'join --reference', which is perhaps
 
472
                # reasonable: adding a new reference is a special operation and
 
473
                # can have a special behaviour.  mbp 20070306
 
474
                mutter("%r is a nested bzr tree", abspath)
531
475
            else:
532
476
                _add_one(self, inv, parent_ie, directory, kind, action)
533
477
                added.append(directory.raw_path)
540
484
                    # without the parent ie, use the relatively slower inventory
541
485
                    # probing method
542
486
                    this_id = inv.path2id(
543
 
                        self._fix_case_of_inventory_path(directory.raw_path))
 
487
                            self._fix_case_of_inventory_path(directory.raw_path))
544
488
                    if this_id is None:
545
489
                        this_ie = None
546
490
                    else:
555
499
                    # faster - its impossible for a non root dir to have a
556
500
                    # control file.
557
501
                    if self.is_control_filename(subp):
558
 
                        trace.mutter("skip control directory %r", subp)
 
502
                        mutter("skip control directory %r", subp)
559
503
                    elif subf in this_ie.children:
560
504
                        # recurse into this already versioned subdir.
561
505
                        dirs_to_add.append((_FastPath(subp, subf), this_ie))
593
537
        for commit which is not required to handle situations that do not arise
594
538
        outside of commit.
595
539
 
596
 
        See the inventory developers documentation for the theory behind
597
 
        inventory deltas.
598
 
 
599
540
        :param new_revid: The new revision id for the trees parent.
600
541
        :param delta: An inventory delta (see apply_inventory_delta) describing
601
542
            the changes from the current left most parent revision to new_revid.
617
558
        inventory = basis.inventory._get_mutable_inventory()
618
559
        basis.unlock()
619
560
        inventory.apply_delta(delta)
620
 
        rev_tree = revisiontree.RevisionTree(self.branch.repository,
621
 
                                             inventory, new_revid)
 
561
        rev_tree = RevisionTree(self.branch.repository, inventory, new_revid)
622
562
        self.set_parent_trees([(new_revid, rev_tree)])
623
563
 
624
564
 
635
575
        self.create_hook(hooks.HookPoint('start_commit',
636
576
            "Called before a commit is performed on a tree. The start commit "
637
577
            "hook is able to change the tree before the commit takes place. "
638
 
            "start_commit is called with the bzrlib.mutabletree.MutableTree "
639
 
            "that the commit is being performed on.", (1, 4), None))
640
 
        self.create_hook(hooks.HookPoint('post_commit',
641
 
            "Called after a commit is performed on a tree. The hook is "
642
 
            "called with a bzrlib.mutabletree.PostCommitHookParams object. "
643
 
            "The mutable tree the commit was performed on is available via "
644
 
            "the mutable_tree attribute of that object.", (2, 0), None))
 
578
            "start_commit is called with the bzrlib.tree.MutableTree that the "
 
579
            "commit is being performed on.", (1, 4), None))
645
580
 
646
581
 
647
582
# install the default hooks into the MutableTree class.
648
583
MutableTree.hooks = MutableTreeHooks()
649
584
 
650
585
 
651
 
class PostCommitHookParams(object):
652
 
    """Parameters for the post_commit hook.
653
 
 
654
 
    To access the parameters, use the following attributes:
655
 
 
656
 
    * mutable_tree - the MutableTree object
657
 
    """
658
 
 
659
 
    def __init__(self, mutable_tree):
660
 
        """Create the parameters for the post_commit hook."""
661
 
        self.mutable_tree = mutable_tree
662
 
 
663
 
 
664
586
class _FastPath(object):
665
587
    """A path object with fast accessors for things like basename."""
666
588
 
707
629
        # there are a limited number of dirs we can be nested under, it should
708
630
        # generally find it very fast and not recurse after that.
709
631
        added = _add_one_and_parent(tree, inv, None,
710
 
            _FastPath(osutils.dirname(path.raw_path)), 'directory', action)
711
 
        parent_id = inv.path2id(osutils.dirname(path.raw_path))
 
632
            _FastPath(dirname(path.raw_path)), 'directory', action)
 
633
        parent_id = inv.path2id(dirname(path.raw_path))
712
634
        parent_ie = inv[parent_id]
713
635
    _add_one(tree, inv, parent_ie, path, kind, action)
714
636
    return added + [path.raw_path]
724
646
        file_id or None to generate a new file id
725
647
    :returns: None
726
648
    """
727
 
    # if the parent exists, but isn't a directory, we have to do the
728
 
    # kind change now -- really the inventory shouldn't pretend to know
729
 
    # the kind of wt files, but it does.
730
 
    if parent_ie.kind != 'directory':
731
 
        # nb: this relies on someone else checking that the path we're using
732
 
        # doesn't contain symlinks.
733
 
        new_parent_ie = inventory.make_entry('directory', parent_ie.name,
734
 
            parent_ie.parent_id, parent_ie.file_id)
735
 
        del inv[parent_ie.file_id]
736
 
        inv.add(new_parent_ie)
737
 
        parent_ie = new_parent_ie
738
649
    file_id = file_id_callback(inv, parent_ie, path, kind)
739
650
    entry = inv.make_entry(kind, path.base_path, parent_ie.file_id,
740
651
        file_id=file_id)