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

  • Committer: Ian Clatworthy
  • Date: 2008-04-17 08:21:14 UTC
  • mto: (4171.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 4173.
  • Revision ID: ian.clatworthy@canonical.com-20080417082114-76imbiarcbj16ov3
first cut at working tree content filtering

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2007 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#            and others
4
4
#
14
14
#
15
15
# You should have received a copy of the GNU General Public License
16
16
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 
19
19
"""Configuration that affects the behaviour of Bazaar.
20
20
 
37
37
[/home/robertc/source]
38
38
recurse=False|True(default)
39
39
email= as above
40
 
check_signatures= as above
 
40
check_signatures= as above 
41
41
create_signatures= as above.
42
42
 
43
43
explanation of options
45
45
editor - this option sets the pop up editor to use during commits.
46
46
email - this option sets the user id bzr will use when committing.
47
47
check_signatures - this option controls whether bzr will require good gpg
48
 
                   signatures, ignore them, or check them if they are
 
48
                   signatures, ignore them, or check them if they are 
49
49
                   present.
50
 
create_signatures - this option controls whether bzr will always create
 
50
create_signatures - this option controls whether bzr will always create 
51
51
                    gpg signatures, never create them, or create them if the
52
52
                    branch is configured to require them.
53
53
log_format - this option sets the default log format.  Possible values are
78
78
    errors,
79
79
    mail_client,
80
80
    osutils,
81
 
    registry,
82
81
    symbol_versioning,
83
82
    trace,
84
83
    ui,
122
121
STORE_BRANCH = 3
123
122
STORE_GLOBAL = 4
124
123
 
125
 
_ConfigObj = None
126
 
def ConfigObj(*args, **kwargs):
127
 
    global _ConfigObj
128
 
    if _ConfigObj is None:
129
 
        class ConfigObj(configobj.ConfigObj):
130
 
 
131
 
            def get_bool(self, section, key):
132
 
                return self[section].as_bool(key)
133
 
 
134
 
            def get_value(self, section, name):
135
 
                # Try [] for the old DEFAULT section.
136
 
                if section == "DEFAULT":
137
 
                    try:
138
 
                        return self[name]
139
 
                    except KeyError:
140
 
                        pass
141
 
                return self[section][name]
142
 
        _ConfigObj = ConfigObj
143
 
    return _ConfigObj(*args, **kwargs)
 
124
 
 
125
class ConfigObj(configobj.ConfigObj):
 
126
 
 
127
    def get_bool(self, section, key):
 
128
        return self[section].as_bool(key)
 
129
 
 
130
    def get_value(self, section, name):
 
131
        # Try [] for the old DEFAULT section.
 
132
        if section == "DEFAULT":
 
133
            try:
 
134
                return self[name]
 
135
            except KeyError:
 
136
                pass
 
137
        return self[section][name]
144
138
 
145
139
 
146
140
class Config(object):
147
141
    """A configuration policy - what username, editor, gpg needs etc."""
148
142
 
149
 
    def __init__(self):
150
 
        super(Config, self).__init__()
151
 
 
152
143
    def get_editor(self):
153
144
        """Get the users pop up editor."""
154
145
        raise NotImplementedError
155
146
 
156
 
    def get_change_editor(self, old_tree, new_tree):
157
 
        from bzrlib import diff
158
 
        cmd = self._get_change_editor()
159
 
        if cmd is None:
160
 
            return None
161
 
        return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
162
 
                                             sys.stdout)
163
 
 
164
 
 
165
147
    def get_mail_client(self):
166
148
        """Get a mail client to use"""
167
149
        selected_client = self.get_user_option('mail_client')
168
 
        _registry = mail_client.mail_client_registry
169
150
        try:
170
 
            mail_client_class = _registry.get(selected_client)
 
151
            mail_client_class = {
 
152
                None: mail_client.DefaultMail,
 
153
                # Specific clients
 
154
                'emacsclient': mail_client.EmacsMail,
 
155
                'evolution': mail_client.Evolution,
 
156
                'kmail': mail_client.KMail,
 
157
                'mutt': mail_client.Mutt,
 
158
                'thunderbird': mail_client.Thunderbird,
 
159
                # Generic options
 
160
                'default': mail_client.DefaultMail,
 
161
                'editor': mail_client.Editor,
 
162
                'mapi': mail_client.MAPIClient,
 
163
                'xdg-email': mail_client.XDGEmail,
 
164
            }[selected_client]
171
165
        except KeyError:
172
166
            raise errors.UnknownMailClient(selected_client)
173
167
        return mail_client_class(self)
186
180
        """Get a generic option - no special process, no default."""
187
181
        return self._get_user_option(option_name)
188
182
 
189
 
    def get_user_option_as_bool(self, option_name):
190
 
        """Get a generic option as a boolean - no special process, no default.
191
 
 
192
 
        :return None if the option doesn't exist or its value can't be
193
 
            interpreted as a boolean. Returns True or False otherwise.
194
 
        """
195
 
        s = self._get_user_option(option_name)
196
 
        if s is None:
197
 
            # The option doesn't exist
198
 
            return None
199
 
        val = ui.bool_from_string(s)
200
 
        if val is None:
201
 
            # The value can't be interpreted as a boolean
202
 
            trace.warning('Value "%s" is not a boolean for "%s"',
203
 
                          s, option_name)
204
 
        return val
205
 
 
206
 
    def get_user_option_as_list(self, option_name):
207
 
        """Get a generic option as a list - no special process, no default.
208
 
 
209
 
        :return None if the option doesn't exist. Returns the value as a list
210
 
            otherwise.
211
 
        """
212
 
        l = self._get_user_option(option_name)
213
 
        if isinstance(l, (str, unicode)):
214
 
            # A single value, most probably the user forgot the final ','
215
 
            l = [l]
216
 
        return l
217
 
 
218
183
    def gpg_signing_command(self):
219
184
        """What program should be used to sign signatures?"""
220
185
        result = self._gpg_signing_command()
237
202
        """See log_format()."""
238
203
        return None
239
204
 
 
205
    def __init__(self):
 
206
        super(Config, self).__init__()
 
207
 
240
208
    def post_commit(self):
241
209
        """An ordered list of python functions to call.
242
210
 
254
222
 
255
223
    def username(self):
256
224
        """Return email-style username.
257
 
 
 
225
    
258
226
        Something similar to 'Martin Pool <mbp@sourcefrog.net>'
259
 
 
260
 
        $BZR_EMAIL can be set to override this, then
 
227
        
 
228
        $BZR_EMAIL can be set to override this (as well as the
 
229
        deprecated $BZREMAIL), then
261
230
        the concrete policy type is checked, and finally
262
231
        $EMAIL is examined.
263
 
        If no username can be found, errors.NoWhoami exception is raised.
264
 
 
 
232
        If none is found, a reasonable default is (hopefully)
 
233
        created.
 
234
    
265
235
        TODO: Check it's reasonably well-formed.
266
236
        """
267
237
        v = os.environ.get('BZR_EMAIL')
268
238
        if v:
269
 
            return v.decode(osutils.get_user_encoding())
 
239
            return v.decode(bzrlib.user_encoding)
270
240
 
271
241
        v = self._get_user_id()
272
242
        if v:
274
244
 
275
245
        v = os.environ.get('EMAIL')
276
246
        if v:
277
 
            return v.decode(osutils.get_user_encoding())
278
 
 
279
 
        raise errors.NoWhoami()
280
 
 
281
 
    def ensure_username(self):
282
 
        """Raise errors.NoWhoami if username is not set.
283
 
 
284
 
        This method relies on the username() function raising the error.
285
 
        """
286
 
        self.username()
 
247
            return v.decode(bzrlib.user_encoding)
 
248
 
 
249
        name, email = _auto_user_id()
 
250
        if name:
 
251
            return '%s <%s>' % (name, email)
 
252
        else:
 
253
            return email
287
254
 
288
255
    def signature_checking(self):
289
256
        """What is the current policy for signature checking?."""
334
301
                path = 'bzr'
335
302
            return path
336
303
 
337
 
    def suppress_warning(self, warning):
338
 
        """Should the warning be suppressed or emitted.
339
 
 
340
 
        :param warning: The name of the warning being tested.
341
 
 
342
 
        :returns: True if the warning should be suppressed, False otherwise.
343
 
        """
344
 
        warnings = self.get_user_option_as_list('suppress_warnings')
345
 
        if warnings is None or warning not in warnings:
346
 
            return False
347
 
        else:
348
 
            return True
349
 
 
350
304
 
351
305
class IniBasedConfig(Config):
352
306
    """A configuration policy that draws from ini files."""
353
307
 
354
 
    def __init__(self, get_filename):
355
 
        super(IniBasedConfig, self).__init__()
356
 
        self._get_filename = get_filename
357
 
        self._parser = None
358
 
 
359
308
    def _get_parser(self, file=None):
360
309
        if self._parser is not None:
361
310
            return self._parser
389
338
        """Return the policy for the given (section, option_name) pair."""
390
339
        return POLICY_NONE
391
340
 
392
 
    def _get_change_editor(self):
393
 
        return self.get_user_option('change_editor')
394
 
 
395
341
    def _get_signature_checking(self):
396
342
        """See Config._get_signature_checking."""
397
343
        policy = self._get_user_option('check_signatures')
441
387
        """See Config.log_format."""
442
388
        return self._get_user_option('log_format')
443
389
 
 
390
    def __init__(self, get_filename):
 
391
        super(IniBasedConfig, self).__init__()
 
392
        self._get_filename = get_filename
 
393
        self._parser = None
 
394
        
444
395
    def _post_commit(self):
445
396
        """See Config.post_commit."""
446
397
        return self._get_user_option('post_commit')
469
420
 
470
421
    def _get_alias(self, value):
471
422
        try:
472
 
            return self._get_parser().get_value("ALIASES",
 
423
            return self._get_parser().get_value("ALIASES", 
473
424
                                                value)
474
425
        except KeyError:
475
426
            pass
489
440
 
490
441
    def set_user_option(self, option, value):
491
442
        """Save option and its value in the configuration."""
492
 
        self._set_option(option, value, 'DEFAULT')
493
 
 
494
 
    def get_aliases(self):
495
 
        """Return the aliases section."""
496
 
        if 'ALIASES' in self._get_parser():
497
 
            return self._get_parser()['ALIASES']
498
 
        else:
499
 
            return {}
500
 
 
501
 
    def set_alias(self, alias_name, alias_command):
502
 
        """Save the alias in the configuration."""
503
 
        self._set_option(alias_name, alias_command, 'ALIASES')
504
 
 
505
 
    def unset_alias(self, alias_name):
506
 
        """Unset an existing alias."""
507
 
        aliases = self._get_parser().get('ALIASES')
508
 
        if not aliases or alias_name not in aliases:
509
 
            raise errors.NoSuchAlias(alias_name)
510
 
        del aliases[alias_name]
511
 
        self._write_config_file()
512
 
 
513
 
    def _set_option(self, option, value, section):
514
443
        # FIXME: RBC 20051029 This should refresh the parser and also take a
515
444
        # file lock on bazaar.conf.
516
445
        conf_dir = os.path.dirname(self._get_filename())
517
446
        ensure_config_dir_exists(conf_dir)
518
 
        self._get_parser().setdefault(section, {})[option] = value
519
 
        self._write_config_file()
520
 
 
521
 
    def _write_config_file(self):
522
 
        path = self._get_filename()
523
 
        f = open(path, 'wb')
524
 
        osutils.copy_ownership_from_path(path)
 
447
        if 'DEFAULT' not in self._get_parser():
 
448
            self._get_parser()['DEFAULT'] = {}
 
449
        self._get_parser()['DEFAULT'][option] = value
 
450
        f = open(self._get_filename(), 'wb')
525
451
        self._get_parser().write(f)
526
452
        f.close()
527
453
 
644
570
 
645
571
    def set_user_option(self, option, value, store=STORE_LOCATION):
646
572
        """Save option and its value in the configuration."""
647
 
        if store not in [STORE_LOCATION,
 
573
        assert store in [STORE_LOCATION,
648
574
                         STORE_LOCATION_NORECURSE,
649
 
                         STORE_LOCATION_APPENDPATH]:
650
 
            raise ValueError('bad storage policy %r for %r' %
651
 
                (store, option))
 
575
                         STORE_LOCATION_APPENDPATH], 'bad storage policy'
652
576
        # FIXME: RBC 20051029 This should refresh the parser and also take a
653
577
        # file lock on locations.conf.
654
578
        conf_dir = os.path.dirname(self._get_filename())
699
623
 
700
624
    def _get_safe_value(self, option_name):
701
625
        """This variant of get_best_value never returns untrusted values.
702
 
 
 
626
        
703
627
        It does not return values from the branch data, because the branch may
704
628
        not be controlled by the user.
705
629
 
714
638
 
715
639
    def _get_user_id(self):
716
640
        """Return the full user id for the branch.
717
 
 
718
 
        e.g. "John Hacker <jhacker@example.com>"
 
641
    
 
642
        e.g. "John Hacker <jhacker@foo.org>"
719
643
        This is looked up in the email controlfile for the branch.
720
644
        """
721
645
        try:
722
 
            return (self.branch._transport.get_bytes("email")
723
 
                    .decode(osutils.get_user_encoding())
 
646
            return (self.branch.control_files.get_utf8("email") 
 
647
                    .read()
 
648
                    .decode(bzrlib.user_encoding)
724
649
                    .rstrip("\r\n"))
725
650
        except errors.NoSuchFile, e:
726
651
            pass
727
 
 
 
652
        
728
653
        return self._get_best_value('_get_user_id')
729
654
 
730
 
    def _get_change_editor(self):
731
 
        return self._get_best_value('_get_change_editor')
732
 
 
733
655
    def _get_signature_checking(self):
734
656
        """See Config._get_signature_checking."""
735
657
        return self._get_best_value('_get_signature_checking')
769
691
                        trace.warning('Value "%s" is masked by "%s" from'
770
692
                                      ' branch.conf', value, mask_value)
771
693
 
 
694
 
772
695
    def _gpg_signing_command(self):
773
696
        """See Config.gpg_signing_command."""
774
697
        return self._get_safe_value('_gpg_signing_command')
775
 
 
 
698
        
776
699
    def __init__(self, branch):
777
700
        super(BranchConfig, self).__init__()
778
701
        self._location_config = None
779
702
        self._branch_data_config = None
780
703
        self._global_config = None
781
704
        self.branch = branch
782
 
        self.option_sources = (self._get_location_config,
 
705
        self.option_sources = (self._get_location_config, 
783
706
                               self._get_branch_data_config,
784
707
                               self._get_global_config)
785
708
 
821
744
            os.mkdir(parent_dir)
822
745
        trace.mutter('creating config directory: %r', path)
823
746
        os.mkdir(path)
824
 
        osutils.copy_ownership_from_path(path)
825
747
 
826
748
 
827
749
def config_dir():
828
750
    """Return per-user configuration directory.
829
751
 
830
752
    By default this is ~/.bazaar/
831
 
 
 
753
    
832
754
    TODO: Global option --config-dir to override this.
833
755
    """
834
756
    base = os.environ.get('BZR_HOME', None)
873
795
    return osutils.pathjoin(config_dir(), 'ignore')
874
796
 
875
797
 
876
 
def crash_dir():
877
 
    """Return the directory name to store crash files.
878
 
 
879
 
    This doesn't implicitly create it.
880
 
 
881
 
    On Windows it's in the config directory; elsewhere it's /var/crash
882
 
    which may be monitored by apport.  It can be overridden by
883
 
    $APPORT_CRASH_DIR.
 
798
def _auto_user_id():
 
799
    """Calculate automatic user identification.
 
800
 
 
801
    Returns (realname, email).
 
802
 
 
803
    Only used when none is set in the environment or the id file.
 
804
 
 
805
    This previously used the FQDN as the default domain, but that can
 
806
    be very slow on machines where DNS is broken.  So now we simply
 
807
    use the hostname.
884
808
    """
 
809
    import socket
 
810
 
885
811
    if sys.platform == 'win32':
886
 
        return osutils.pathjoin(config_dir(), 'Crash')
887
 
    else:
888
 
        # XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
889
 
        # 2010-01-31
890
 
        return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
891
 
 
892
 
 
893
 
def xdg_cache_dir():
894
 
    # See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
895
 
    # Possibly this should be different on Windows?
896
 
    e = os.environ.get('XDG_CACHE_DIR', None)
897
 
    if e:
898
 
        return e
899
 
    else:
900
 
        return os.path.expanduser('~/.cache')
 
812
        name = win32utils.get_user_name_unicode()
 
813
        if name is None:
 
814
            raise errors.BzrError("Cannot autodetect user name.\n"
 
815
                                  "Please, set your name with command like:\n"
 
816
                                  'bzr whoami "Your Name <name@domain.com>"')
 
817
        host = win32utils.get_host_name_unicode()
 
818
        if host is None:
 
819
            host = socket.gethostname()
 
820
        return name, (name + '@' + host)
 
821
 
 
822
    try:
 
823
        import pwd
 
824
        uid = os.getuid()
 
825
        w = pwd.getpwuid(uid)
 
826
 
 
827
        # we try utf-8 first, because on many variants (like Linux),
 
828
        # /etc/passwd "should" be in utf-8, and because it's unlikely to give
 
829
        # false positives.  (many users will have their user encoding set to
 
830
        # latin-1, which cannot raise UnicodeError.)
 
831
        try:
 
832
            gecos = w.pw_gecos.decode('utf-8')
 
833
            encoding = 'utf-8'
 
834
        except UnicodeError:
 
835
            try:
 
836
                gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
837
                encoding = bzrlib.user_encoding
 
838
            except UnicodeError:
 
839
                raise errors.BzrCommandError('Unable to determine your name.  '
 
840
                   'Use "bzr whoami" to set it.')
 
841
        try:
 
842
            username = w.pw_name.decode(encoding)
 
843
        except UnicodeError:
 
844
            raise errors.BzrCommandError('Unable to determine your name.  '
 
845
                'Use "bzr whoami" to set it.')
 
846
 
 
847
        comma = gecos.find(',')
 
848
        if comma == -1:
 
849
            realname = gecos
 
850
        else:
 
851
            realname = gecos[:comma]
 
852
        if not realname:
 
853
            realname = username
 
854
 
 
855
    except ImportError:
 
856
        import getpass
 
857
        try:
 
858
            realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
859
        except UnicodeDecodeError:
 
860
            raise errors.BzrError("Can't decode username as %s." % \
 
861
                    bzrlib.user_encoding)
 
862
 
 
863
    return realname, (username + '@' + socket.gethostname())
901
864
 
902
865
 
903
866
def parse_username(username):
912
875
def extract_email_address(e):
913
876
    """Return just the address part of an email string.
914
877
 
915
 
    That is just the user@domain part, nothing else.
 
878
    That is just the user@domain part, nothing else. 
916
879
    This part is required to contain only ascii characters.
917
880
    If it can't be extracted, raises an error.
918
881
 
928
891
class TreeConfig(IniBasedConfig):
929
892
    """Branch configuration data associated with its contents, not location"""
930
893
 
931
 
    # XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
932
 
 
933
894
    def __init__(self, branch):
934
 
        self._config = branch._get_config()
 
895
        transport = branch.control_files._transport
 
896
        self._config = TransportConfig(transport, 'branch.conf')
935
897
        self.branch = branch
936
898
 
937
899
    def _get_parser(self, file=None):
945
907
            return self._config.get_option(name, section, default)
946
908
        finally:
947
909
            self.branch.unlock()
 
910
        return result
948
911
 
949
912
    def set_option(self, value, name, section=None):
950
913
        """Set a per-branch configuration option"""
1003
966
        section[option_name] = value
1004
967
        self._save()
1005
968
 
1006
 
    def get_credentials(self, scheme, host, port=None, user=None, path=None, 
1007
 
                        realm=None):
 
969
    def get_credentials(self, scheme, host, port=None, user=None, path=None):
1008
970
        """Returns the matching credentials from authentication.conf file.
1009
971
 
1010
972
        :param scheme: protocol
1016
978
        :param user: login (optional)
1017
979
 
1018
980
        :param path: the absolute path on the server (optional)
1019
 
        
1020
 
        :param realm: the http authentication realm (optional)
1021
981
 
1022
982
        :return: A dict containing the matching credentials or None.
1023
983
           This includes:
1024
984
           - name: the section name of the credentials in the
1025
985
             authentication.conf file,
1026
 
           - user: can't be different from the provided user if any,
1027
 
           - scheme: the server protocol,
1028
 
           - host: the server address,
1029
 
           - port: the server port (can be None),
1030
 
           - path: the absolute server path (can be None),
1031
 
           - realm: the http specific authentication realm (can be None),
 
986
           - user: can't de different from the provided user if any,
1032
987
           - password: the decoded password, could be None if the credential
1033
988
             defines only the user
1034
989
           - verify_certificates: https specific, True if the server
1036
991
        """
1037
992
        credentials = None
1038
993
        for auth_def_name, auth_def in self._get_config().items():
1039
 
            if type(auth_def) is not configobj.Section:
1040
 
                raise ValueError("%s defined outside a section" % auth_def_name)
1041
 
 
1042
994
            a_scheme, a_host, a_user, a_path = map(
1043
995
                auth_def.get, ['scheme', 'host', 'user', 'path'])
1044
996
 
1075
1027
            if a_user is None:
1076
1028
                # Can't find a user
1077
1029
                continue
1078
 
            # Prepare a credentials dictionary with additional keys
1079
 
            # for the credential providers
1080
1030
            credentials = dict(name=auth_def_name,
1081
 
                               user=a_user,
1082
 
                               scheme=a_scheme,
1083
 
                               host=host,
1084
 
                               port=port,
1085
 
                               path=path,
1086
 
                               realm=realm,
1087
 
                               password=auth_def.get('password', None),
 
1031
                               user=a_user, password=auth_def['password'],
1088
1032
                               verify_certificates=a_verify_certificates)
1089
 
            # Decode the password in the credentials (or get one)
1090
1033
            self.decode_password(credentials,
1091
1034
                                 auth_def.get('password_encoding', None))
1092
1035
            if 'auth' in debug.debug_flags:
1093
1036
                trace.mutter("Using authentication section: %r", auth_def_name)
1094
1037
            break
1095
1038
 
1096
 
        if credentials is None:
1097
 
            # No credentials were found in authentication.conf, try the fallback
1098
 
            # credentials stores.
1099
 
            credentials = credential_store_registry.get_fallback_credentials(
1100
 
                scheme, host, port, user, path, realm)
1101
 
 
1102
1039
        return credentials
1103
1040
 
1104
 
    def set_credentials(self, name, host, user, scheme=None, password=None,
1105
 
                        port=None, path=None, verify_certificates=None,
1106
 
                        realm=None):
1107
 
        """Set authentication credentials for a host.
1108
 
 
1109
 
        Any existing credentials with matching scheme, host, port and path
1110
 
        will be deleted, regardless of name.
1111
 
 
1112
 
        :param name: An arbitrary name to describe this set of credentials.
1113
 
        :param host: Name of the host that accepts these credentials.
1114
 
        :param user: The username portion of these credentials.
1115
 
        :param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1116
 
            to.
1117
 
        :param password: Password portion of these credentials.
1118
 
        :param port: The IP port on the host that these credentials apply to.
1119
 
        :param path: A filesystem path on the host that these credentials
1120
 
            apply to.
1121
 
        :param verify_certificates: On https, verify server certificates if
1122
 
            True.
1123
 
        :param realm: The http authentication realm (optional).
1124
 
        """
1125
 
        values = {'host': host, 'user': user}
1126
 
        if password is not None:
1127
 
            values['password'] = password
1128
 
        if scheme is not None:
1129
 
            values['scheme'] = scheme
1130
 
        if port is not None:
1131
 
            values['port'] = '%d' % port
1132
 
        if path is not None:
1133
 
            values['path'] = path
1134
 
        if verify_certificates is not None:
1135
 
            values['verify_certificates'] = str(verify_certificates)
1136
 
        if realm is not None:
1137
 
            values['realm'] = realm
1138
 
        config = self._get_config()
1139
 
        for_deletion = []
1140
 
        for section, existing_values in config.items():
1141
 
            for key in ('scheme', 'host', 'port', 'path', 'realm'):
1142
 
                if existing_values.get(key) != values.get(key):
1143
 
                    break
1144
 
            else:
1145
 
                del config[section]
1146
 
        config.update({name: values})
1147
 
        self._save()
1148
 
 
1149
 
    def get_user(self, scheme, host, port=None, realm=None, path=None,
1150
 
                 prompt=None, ask=False, default=None):
 
1041
    def get_user(self, scheme, host, port=None,
 
1042
                 realm=None, path=None, prompt=None):
1151
1043
        """Get a user from authentication file.
1152
1044
 
1153
1045
        :param scheme: protocol
1160
1052
 
1161
1053
        :param path: the absolute path on the server (optional)
1162
1054
 
1163
 
        :param ask: Ask the user if there is no explicitly configured username 
1164
 
                    (optional)
1165
 
 
1166
 
        :param default: The username returned if none is defined (optional).
1167
 
 
1168
1055
        :return: The found user.
1169
1056
        """
1170
1057
        credentials = self.get_credentials(scheme, host, port, user=None,
1171
 
                                           path=path, realm=realm)
 
1058
                                           path=path)
1172
1059
        if credentials is not None:
1173
1060
            user = credentials['user']
1174
1061
        else:
1175
1062
            user = None
1176
 
        if user is None:
1177
 
            if ask:
1178
 
                if prompt is None:
1179
 
                    # Create a default prompt suitable for most cases
1180
 
                    prompt = scheme.upper() + ' %(host)s username'
1181
 
                # Special handling for optional fields in the prompt
1182
 
                if port is not None:
1183
 
                    prompt_host = '%s:%d' % (host, port)
1184
 
                else:
1185
 
                    prompt_host = host
1186
 
                user = ui.ui_factory.get_username(prompt, host=prompt_host)
1187
 
            else:
1188
 
                user = default
1189
1063
        return user
1190
1064
 
1191
1065
    def get_password(self, scheme, host, user, port=None,
1206
1080
 
1207
1081
        :return: The found password or the one entered by the user.
1208
1082
        """
1209
 
        credentials = self.get_credentials(scheme, host, port, user, path,
1210
 
                                           realm)
 
1083
        credentials = self.get_credentials(scheme, host, port, user, path)
1211
1084
        if credentials is not None:
1212
1085
            password = credentials['password']
1213
 
            if password is not None and scheme is 'ssh':
1214
 
                trace.warning('password ignored in section [%s],'
1215
 
                              ' use an ssh agent instead'
1216
 
                              % credentials['name'])
1217
 
                password = None
1218
1086
        else:
1219
1087
            password = None
1220
1088
        # Prompt user only if we could't find a password
1221
1089
        if password is None:
1222
1090
            if prompt is None:
1223
 
                # Create a default prompt suitable for most cases
 
1091
                # Create a default prompt suitable for most of the cases
1224
1092
                prompt = '%s' % scheme.upper() + ' %(user)s@%(host)s password'
1225
1093
            # Special handling for optional fields in the prompt
1226
1094
            if port is not None:
1232
1100
        return password
1233
1101
 
1234
1102
    def decode_password(self, credentials, encoding):
1235
 
        try:
1236
 
            cs = credential_store_registry.get_credential_store(encoding)
1237
 
        except KeyError:
1238
 
            raise ValueError('%r is not a known password_encoding' % encoding)
1239
 
        credentials['password'] = cs.decode_password(credentials)
1240
 
        return credentials
1241
 
 
1242
 
 
1243
 
class CredentialStoreRegistry(registry.Registry):
1244
 
    """A class that registers credential stores.
1245
 
 
1246
 
    A credential store provides access to credentials via the password_encoding
1247
 
    field in authentication.conf sections.
1248
 
 
1249
 
    Except for stores provided by bzr itself, most stores are expected to be
1250
 
    provided by plugins that will therefore use
1251
 
    register_lazy(password_encoding, module_name, member_name, help=help,
1252
 
    fallback=fallback) to install themselves.
1253
 
 
1254
 
    A fallback credential store is one that is queried if no credentials can be
1255
 
    found via authentication.conf.
1256
 
    """
1257
 
 
1258
 
    def get_credential_store(self, encoding=None):
1259
 
        cs = self.get(encoding)
1260
 
        if callable(cs):
1261
 
            cs = cs()
1262
 
        return cs
1263
 
 
1264
 
    def is_fallback(self, name):
1265
 
        """Check if the named credentials store should be used as fallback."""
1266
 
        return self.get_info(name)
1267
 
 
1268
 
    def get_fallback_credentials(self, scheme, host, port=None, user=None,
1269
 
                                 path=None, realm=None):
1270
 
        """Request credentials from all fallback credentials stores.
1271
 
 
1272
 
        The first credentials store that can provide credentials wins.
1273
 
        """
1274
 
        credentials = None
1275
 
        for name in self.keys():
1276
 
            if not self.is_fallback(name):
1277
 
                continue
1278
 
            cs = self.get_credential_store(name)
1279
 
            credentials = cs.get_credentials(scheme, host, port, user,
1280
 
                                             path, realm)
1281
 
            if credentials is not None:
1282
 
                # We found some credentials
1283
 
                break
1284
 
        return credentials
1285
 
 
1286
 
    def register(self, key, obj, help=None, override_existing=False,
1287
 
                 fallback=False):
1288
 
        """Register a new object to a name.
1289
 
 
1290
 
        :param key: This is the key to use to request the object later.
1291
 
        :param obj: The object to register.
1292
 
        :param help: Help text for this entry. This may be a string or
1293
 
                a callable. If it is a callable, it should take two
1294
 
                parameters (registry, key): this registry and the key that
1295
 
                the help was registered under.
1296
 
        :param override_existing: Raise KeyErorr if False and something has
1297
 
                already been registered for that key. If True, ignore if there
1298
 
                is an existing key (always register the new value).
1299
 
        :param fallback: Whether this credential store should be 
1300
 
                used as fallback.
1301
 
        """
1302
 
        return super(CredentialStoreRegistry,
1303
 
                     self).register(key, obj, help, info=fallback,
1304
 
                                    override_existing=override_existing)
1305
 
 
1306
 
    def register_lazy(self, key, module_name, member_name,
1307
 
                      help=None, override_existing=False,
1308
 
                      fallback=False):
1309
 
        """Register a new credential store to be loaded on request.
1310
 
 
1311
 
        :param module_name: The python path to the module. Such as 'os.path'.
1312
 
        :param member_name: The member of the module to return.  If empty or
1313
 
                None, get() will return the module itself.
1314
 
        :param help: Help text for this entry. This may be a string or
1315
 
                a callable.
1316
 
        :param override_existing: If True, replace the existing object
1317
 
                with the new one. If False, if there is already something
1318
 
                registered with the same key, raise a KeyError
1319
 
        :param fallback: Whether this credential store should be 
1320
 
                used as fallback.
1321
 
        """
1322
 
        return super(CredentialStoreRegistry, self).register_lazy(
1323
 
            key, module_name, member_name, help,
1324
 
            info=fallback, override_existing=override_existing)
1325
 
 
1326
 
 
1327
 
credential_store_registry = CredentialStoreRegistry()
1328
 
 
1329
 
 
1330
 
class CredentialStore(object):
1331
 
    """An abstract class to implement storage for credentials"""
1332
 
 
1333
 
    def decode_password(self, credentials):
1334
 
        """Returns a clear text password for the provided credentials."""
1335
 
        raise NotImplementedError(self.decode_password)
1336
 
 
1337
 
    def get_credentials(self, scheme, host, port=None, user=None, path=None,
1338
 
                        realm=None):
1339
 
        """Return the matching credentials from this credential store.
1340
 
 
1341
 
        This method is only called on fallback credential stores.
1342
 
        """
1343
 
        raise NotImplementedError(self.get_credentials)
1344
 
 
1345
 
 
1346
 
 
1347
 
class PlainTextCredentialStore(CredentialStore):
1348
 
    __doc__ = """Plain text credential store for the authentication.conf file"""
1349
 
 
1350
 
    def decode_password(self, credentials):
1351
 
        """See CredentialStore.decode_password."""
1352
 
        return credentials['password']
1353
 
 
1354
 
 
1355
 
credential_store_registry.register('plain', PlainTextCredentialStore,
1356
 
                                   help=PlainTextCredentialStore.__doc__)
1357
 
credential_store_registry.default_key = 'plain'
1358
 
 
1359
 
 
1360
 
class BzrDirConfig(object):
1361
 
 
1362
 
    def __init__(self, bzrdir):
1363
 
        self._bzrdir = bzrdir
1364
 
        self._config = bzrdir._get_config()
1365
 
 
1366
 
    def set_default_stack_on(self, value):
1367
 
        """Set the default stacking location.
1368
 
 
1369
 
        It may be set to a location, or None.
1370
 
 
1371
 
        This policy affects all branches contained by this bzrdir, except for
1372
 
        those under repositories.
1373
 
        """
1374
 
        if self._config is None:
1375
 
            raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
1376
 
        if value is None:
1377
 
            self._config.set_option('', 'default_stack_on')
1378
 
        else:
1379
 
            self._config.set_option(value, 'default_stack_on')
1380
 
 
1381
 
    def get_default_stack_on(self):
1382
 
        """Return the default stacking location.
1383
 
 
1384
 
        This will either be a location, or None.
1385
 
 
1386
 
        This policy affects all branches contained by this bzrdir, except for
1387
 
        those under repositories.
1388
 
        """
1389
 
        if self._config is None:
1390
 
            return None
1391
 
        value = self._config.get_option('default_stack_on')
1392
 
        if value == '':
1393
 
            value = None
1394
 
        return value
 
1103
        return credentials
1395
1104
 
1396
1105
 
1397
1106
class TransportConfig(object):
1438
1147
            configobj.setdefault(section, {})[name] = value
1439
1148
        self._set_configobj(configobj)
1440
1149
 
1441
 
    def _get_config_file(self):
 
1150
    def _get_configobj(self):
1442
1151
        try:
1443
 
            return StringIO(self._transport.get_bytes(self._filename))
 
1152
            return ConfigObj(self._transport.get(self._filename),
 
1153
                             encoding='utf-8')
1444
1154
        except errors.NoSuchFile:
1445
 
            return StringIO()
1446
 
 
1447
 
    def _get_configobj(self):
1448
 
        return ConfigObj(self._get_config_file(), encoding='utf-8')
 
1155
            return ConfigObj(encoding='utf-8')
1449
1156
 
1450
1157
    def _set_configobj(self, configobj):
1451
1158
        out_file = StringIO()