/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: Vincent Ladeuil
  • Date: 2007-10-23 07:15:13 UTC
  • mfrom: (2926 +trunk)
  • mto: (2961.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 2962.
  • Revision ID: v.ladeuil+lp@free.fr-20071023071513-elryt6g2at34d2ur
merge bzr.dev

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
63
63
"""
64
64
 
65
65
import os
 
66
import getpass
66
67
import sys
67
68
 
68
69
from bzrlib.lazy_import import lazy_import
70
71
import errno
71
72
from fnmatch import fnmatch
72
73
import re
73
 
from cStringIO import StringIO
 
74
# FIXME: Why not CStringIO ? -- vila 20071019
 
75
from StringIO import StringIO
74
76
 
75
77
import bzrlib
76
78
from bzrlib import (
78
80
    errors,
79
81
    mail_client,
80
82
    osutils,
81
 
    registry,
82
83
    symbol_versioning,
83
84
    trace,
84
85
    ui,
85
86
    urlutils,
86
87
    win32utils,
87
88
    )
88
 
from bzrlib.util.configobj import configobj
 
89
import bzrlib.util.configobj.configobj as configobj
89
90
""")
90
91
 
91
92
 
122
123
STORE_BRANCH = 3
123
124
STORE_GLOBAL = 4
124
125
 
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)
 
126
 
 
127
class ConfigObj(configobj.ConfigObj):
 
128
 
 
129
    def get_bool(self, section, key):
 
130
        return self[section].as_bool(key)
 
131
 
 
132
    def get_value(self, section, name):
 
133
        # Try [] for the old DEFAULT section.
 
134
        if section == "DEFAULT":
 
135
            try:
 
136
                return self[name]
 
137
            except KeyError:
 
138
                pass
 
139
        return self[section][name]
144
140
 
145
141
 
146
142
class Config(object):
147
143
    """A configuration policy - what username, editor, gpg needs etc."""
148
144
 
149
 
    def __init__(self):
150
 
        super(Config, self).__init__()
151
 
 
152
145
    def get_editor(self):
153
146
        """Get the users pop up editor."""
154
147
        raise NotImplementedError
155
148
 
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
149
    def get_mail_client(self):
166
150
        """Get a mail client to use"""
167
151
        selected_client = self.get_user_option('mail_client')
168
 
        _registry = mail_client.mail_client_registry
169
152
        try:
170
 
            mail_client_class = _registry.get(selected_client)
 
153
            mail_client_class = {
 
154
                None: mail_client.DefaultMail,
 
155
                # Specific clients
 
156
                'evolution': mail_client.Evolution,
 
157
                'kmail': mail_client.KMail,
 
158
                'mutt': mail_client.Mutt,
 
159
                'thunderbird': mail_client.Thunderbird,
 
160
                # Generic options
 
161
                'default': mail_client.DefaultMail,
 
162
                'editor': mail_client.Editor,
 
163
                'mapi': mail_client.MAPIClient,
 
164
                'xdg-email': mail_client.XDGEmail,
 
165
            }[selected_client]
171
166
        except KeyError:
172
167
            raise errors.UnknownMailClient(selected_client)
173
168
        return mail_client_class(self)
186
181
        """Get a generic option - no special process, no default."""
187
182
        return self._get_user_option(option_name)
188
183
 
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
184
    def gpg_signing_command(self):
219
185
        """What program should be used to sign signatures?"""
220
186
        result = self._gpg_signing_command()
237
203
        """See log_format()."""
238
204
        return None
239
205
 
 
206
    def __init__(self):
 
207
        super(Config, self).__init__()
 
208
 
240
209
    def post_commit(self):
241
210
        """An ordered list of python functions to call.
242
211
 
254
223
 
255
224
    def username(self):
256
225
        """Return email-style username.
257
 
 
 
226
    
258
227
        Something similar to 'Martin Pool <mbp@sourcefrog.net>'
259
 
 
 
228
        
260
229
        $BZR_EMAIL can be set to override this (as well as the
261
230
        deprecated $BZREMAIL), then
262
231
        the concrete policy type is checked, and finally
263
232
        $EMAIL is examined.
264
233
        If none is found, a reasonable default is (hopefully)
265
234
        created.
266
 
 
 
235
    
267
236
        TODO: Check it's reasonably well-formed.
268
237
        """
269
238
        v = os.environ.get('BZR_EMAIL')
270
239
        if v:
271
 
            return v.decode(osutils.get_user_encoding())
 
240
            return v.decode(bzrlib.user_encoding)
 
241
        v = os.environ.get('BZREMAIL')
 
242
        if v:
 
243
            # FIXME: Seems to have been deprecated since more than a year now,
 
244
            # time to delete ? -- vila 20071019
 
245
            trace.warning('BZREMAIL is deprecated in favor of BZR_EMAIL.'
 
246
                          ' Please update your configuration.')
 
247
            return v.decode(bzrlib.user_encoding)
272
248
 
273
249
        v = self._get_user_id()
274
250
        if v:
276
252
 
277
253
        v = os.environ.get('EMAIL')
278
254
        if v:
279
 
            return v.decode(osutils.get_user_encoding())
 
255
            return v.decode(bzrlib.user_encoding)
280
256
 
281
257
        name, email = _auto_user_id()
282
258
        if name:
333
309
                path = 'bzr'
334
310
            return path
335
311
 
336
 
    def suppress_warning(self, warning):
337
 
        """Should the warning be suppressed or emitted.
338
 
 
339
 
        :param warning: The name of the warning being tested.
340
 
 
341
 
        :returns: True if the warning should be suppressed, False otherwise.
342
 
        """
343
 
        warnings = self.get_user_option_as_list('suppress_warnings')
344
 
        if warnings is None or warning not in warnings:
345
 
            return False
346
 
        else:
347
 
            return True
348
 
 
349
312
 
350
313
class IniBasedConfig(Config):
351
314
    """A configuration policy that draws from ini files."""
352
315
 
353
 
    def __init__(self, get_filename):
354
 
        super(IniBasedConfig, self).__init__()
355
 
        self._get_filename = get_filename
356
 
        self._parser = None
357
 
 
358
316
    def _get_parser(self, file=None):
359
317
        if self._parser is not None:
360
318
            return self._parser
388
346
        """Return the policy for the given (section, option_name) pair."""
389
347
        return POLICY_NONE
390
348
 
391
 
    def _get_change_editor(self):
392
 
        return self.get_user_option('change_editor')
393
 
 
394
349
    def _get_signature_checking(self):
395
350
        """See Config._get_signature_checking."""
396
351
        policy = self._get_user_option('check_signatures')
440
395
        """See Config.log_format."""
441
396
        return self._get_user_option('log_format')
442
397
 
 
398
    def __init__(self, get_filename):
 
399
        super(IniBasedConfig, self).__init__()
 
400
        self._get_filename = get_filename
 
401
        self._parser = None
 
402
        
443
403
    def _post_commit(self):
444
404
        """See Config.post_commit."""
445
405
        return self._get_user_option('post_commit')
468
428
 
469
429
    def _get_alias(self, value):
470
430
        try:
471
 
            return self._get_parser().get_value("ALIASES",
 
431
            return self._get_parser().get_value("ALIASES", 
472
432
                                                value)
473
433
        except KeyError:
474
434
            pass
488
448
 
489
449
    def set_user_option(self, option, value):
490
450
        """Save option and its value in the configuration."""
491
 
        self._set_option(option, value, 'DEFAULT')
492
 
 
493
 
    def get_aliases(self):
494
 
        """Return the aliases section."""
495
 
        if 'ALIASES' in self._get_parser():
496
 
            return self._get_parser()['ALIASES']
497
 
        else:
498
 
            return {}
499
 
 
500
 
    def set_alias(self, alias_name, alias_command):
501
 
        """Save the alias in the configuration."""
502
 
        self._set_option(alias_name, alias_command, 'ALIASES')
503
 
 
504
 
    def unset_alias(self, alias_name):
505
 
        """Unset an existing alias."""
506
 
        aliases = self._get_parser().get('ALIASES')
507
 
        if not aliases or alias_name not in aliases:
508
 
            raise errors.NoSuchAlias(alias_name)
509
 
        del aliases[alias_name]
510
 
        self._write_config_file()
511
 
 
512
 
    def _set_option(self, option, value, section):
513
451
        # FIXME: RBC 20051029 This should refresh the parser and also take a
514
452
        # file lock on bazaar.conf.
515
453
        conf_dir = os.path.dirname(self._get_filename())
516
454
        ensure_config_dir_exists(conf_dir)
517
 
        self._get_parser().setdefault(section, {})[option] = value
518
 
        self._write_config_file()
519
 
 
520
 
    def _write_config_file(self):
521
 
        path = self._get_filename()
522
 
        f = open(path, 'wb')
523
 
        osutils.copy_ownership_from_path(path)
 
455
        if 'DEFAULT' not in self._get_parser():
 
456
            self._get_parser()['DEFAULT'] = {}
 
457
        self._get_parser()['DEFAULT'][option] = value
 
458
        f = open(self._get_filename(), 'wb')
524
459
        self._get_parser().write(f)
525
460
        f.close()
526
461
 
643
578
 
644
579
    def set_user_option(self, option, value, store=STORE_LOCATION):
645
580
        """Save option and its value in the configuration."""
646
 
        if store not in [STORE_LOCATION,
 
581
        assert store in [STORE_LOCATION,
647
582
                         STORE_LOCATION_NORECURSE,
648
 
                         STORE_LOCATION_APPENDPATH]:
649
 
            raise ValueError('bad storage policy %r for %r' %
650
 
                (store, option))
 
583
                         STORE_LOCATION_APPENDPATH], 'bad storage policy'
651
584
        # FIXME: RBC 20051029 This should refresh the parser and also take a
652
585
        # file lock on locations.conf.
653
586
        conf_dir = os.path.dirname(self._get_filename())
698
631
 
699
632
    def _get_safe_value(self, option_name):
700
633
        """This variant of get_best_value never returns untrusted values.
701
 
 
 
634
        
702
635
        It does not return values from the branch data, because the branch may
703
636
        not be controlled by the user.
704
637
 
713
646
 
714
647
    def _get_user_id(self):
715
648
        """Return the full user id for the branch.
716
 
 
717
 
        e.g. "John Hacker <jhacker@example.com>"
 
649
    
 
650
        e.g. "John Hacker <jhacker@foo.org>"
718
651
        This is looked up in the email controlfile for the branch.
719
652
        """
720
653
        try:
721
 
            return (self.branch._transport.get_bytes("email")
722
 
                    .decode(osutils.get_user_encoding())
 
654
            return (self.branch.control_files.get_utf8("email") 
 
655
                    .read()
 
656
                    .decode(bzrlib.user_encoding)
723
657
                    .rstrip("\r\n"))
724
658
        except errors.NoSuchFile, e:
725
659
            pass
726
 
 
 
660
        
727
661
        return self._get_best_value('_get_user_id')
728
662
 
729
 
    def _get_change_editor(self):
730
 
        return self._get_best_value('_get_change_editor')
731
 
 
732
663
    def _get_signature_checking(self):
733
664
        """See Config._get_signature_checking."""
734
665
        return self._get_best_value('_get_signature_checking')
768
699
                        trace.warning('Value "%s" is masked by "%s" from'
769
700
                                      ' branch.conf', value, mask_value)
770
701
 
 
702
 
771
703
    def _gpg_signing_command(self):
772
704
        """See Config.gpg_signing_command."""
773
705
        return self._get_safe_value('_gpg_signing_command')
774
 
 
 
706
        
775
707
    def __init__(self, branch):
776
708
        super(BranchConfig, self).__init__()
777
709
        self._location_config = None
778
710
        self._branch_data_config = None
779
711
        self._global_config = None
780
712
        self.branch = branch
781
 
        self.option_sources = (self._get_location_config,
 
713
        self.option_sources = (self._get_location_config, 
782
714
                               self._get_branch_data_config,
783
715
                               self._get_global_config)
784
716
 
820
752
            os.mkdir(parent_dir)
821
753
        trace.mutter('creating config directory: %r', path)
822
754
        os.mkdir(path)
823
 
        osutils.copy_ownership_from_path(path)
824
755
 
825
756
 
826
757
def config_dir():
827
758
    """Return per-user configuration directory.
828
759
 
829
760
    By default this is ~/.bazaar/
830
 
 
 
761
    
831
762
    TODO: Global option --config-dir to override this.
832
763
    """
833
764
    base = os.environ.get('BZR_HOME', None)
837
768
        if base is None:
838
769
            base = os.environ.get('HOME', None)
839
770
        if base is None:
840
 
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
841
 
                                  ' or HOME set')
 
771
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
842
772
        return osutils.pathjoin(base, 'bazaar', '2.0')
843
773
    else:
844
774
        # cygwin, linux, and darwin all have a $HOME directory
872
802
    return osutils.pathjoin(config_dir(), 'ignore')
873
803
 
874
804
 
875
 
def crash_dir():
876
 
    """Return the directory name to store crash files.
877
 
 
878
 
    This doesn't implicitly create it.
879
 
 
880
 
    On Windows it's in the config directory; elsewhere it's /var/crash
881
 
    which may be monitored by apport.  It can be overridden by
882
 
    $APPORT_CRASH_DIR.
883
 
    """
884
 
    if sys.platform == 'win32':
885
 
        return osutils.pathjoin(config_dir(), 'Crash')
886
 
    else:
887
 
        # XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
888
 
        # 2010-01-31
889
 
        return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
890
 
 
891
 
 
892
 
def xdg_cache_dir():
893
 
    # See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
894
 
    # Possibly this should be different on Windows?
895
 
    e = os.environ.get('XDG_CACHE_DIR', None)
896
 
    if e:
897
 
        return e
898
 
    else:
899
 
        return os.path.expanduser('~/.cache')
900
 
 
901
 
 
902
805
def _auto_user_id():
903
806
    """Calculate automatic user identification.
904
807
 
926
829
    try:
927
830
        import pwd
928
831
        uid = os.getuid()
929
 
        try:
930
 
            w = pwd.getpwuid(uid)
931
 
        except KeyError:
932
 
            raise errors.BzrCommandError('Unable to determine your name.  '
933
 
                'Please use "bzr whoami" to set it.')
 
832
        w = pwd.getpwuid(uid)
934
833
 
935
834
        # we try utf-8 first, because on many variants (like Linux),
936
835
        # /etc/passwd "should" be in utf-8, and because it's unlikely to give
941
840
            encoding = 'utf-8'
942
841
        except UnicodeError:
943
842
            try:
944
 
                encoding = osutils.get_user_encoding()
945
 
                gecos = w.pw_gecos.decode(encoding)
 
843
                gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
844
                encoding = bzrlib.user_encoding
946
845
            except UnicodeError:
947
846
                raise errors.BzrCommandError('Unable to determine your name.  '
948
847
                   'Use "bzr whoami" to set it.')
963
862
    except ImportError:
964
863
        import getpass
965
864
        try:
966
 
            user_encoding = osutils.get_user_encoding()
967
 
            realname = username = getpass.getuser().decode(user_encoding)
 
865
            realname = username = getpass.getuser().decode(bzrlib.user_encoding)
968
866
        except UnicodeDecodeError:
969
867
            raise errors.BzrError("Can't decode username as %s." % \
970
 
                    user_encoding)
 
868
                    bzrlib.user_encoding)
971
869
 
972
870
    return realname, (username + '@' + socket.gethostname())
973
871
 
974
872
 
975
 
def parse_username(username):
976
 
    """Parse e-mail username and return a (name, address) tuple."""
977
 
    match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
978
 
    if match is None:
979
 
        return (username, '')
980
 
    else:
981
 
        return (match.group(1), match.group(2))
982
 
 
983
 
 
984
873
def extract_email_address(e):
985
874
    """Return just the address part of an email string.
986
 
 
987
 
    That is just the user@domain part, nothing else.
 
875
    
 
876
    That is just the user@domain part, nothing else. 
988
877
    This part is required to contain only ascii characters.
989
878
    If it can't be extracted, raises an error.
990
 
 
 
879
    
991
880
    >>> extract_email_address('Jane Tester <jane@test.com>')
992
881
    "jane@test.com"
993
882
    """
994
 
    name, email = parse_username(e)
995
 
    if not email:
 
883
    m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
884
    if not m:
996
885
        raise errors.NoEmailInUsername(e)
997
 
    return email
 
886
    return m.group(0)
998
887
 
999
888
 
1000
889
class TreeConfig(IniBasedConfig):
1001
890
    """Branch configuration data associated with its contents, not location"""
1002
891
 
1003
 
    # XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1004
 
 
1005
892
    def __init__(self, branch):
1006
 
        self._config = branch._get_config()
1007
893
        self.branch = branch
1008
894
 
1009
895
    def _get_parser(self, file=None):
1010
896
        if file is not None:
1011
897
            return IniBasedConfig._get_parser(file)
1012
 
        return self._config._get_configobj()
 
898
        return self._get_config()
 
899
 
 
900
    def _get_config(self):
 
901
        try:
 
902
            obj = ConfigObj(self.branch.control_files.get('branch.conf'),
 
903
                            encoding='utf-8')
 
904
        except errors.NoSuchFile:
 
905
            obj = ConfigObj(encoding='utf=8')
 
906
        return obj
1013
907
 
1014
908
    def get_option(self, name, section=None, default=None):
1015
909
        self.branch.lock_read()
1016
910
        try:
1017
 
            return self._config.get_option(name, section, default)
 
911
            obj = self._get_config()
 
912
            try:
 
913
                if section is not None:
 
914
                    obj = obj[section]
 
915
                result = obj[name]
 
916
            except KeyError:
 
917
                result = default
1018
918
        finally:
1019
919
            self.branch.unlock()
 
920
        return result
1020
921
 
1021
922
    def set_option(self, value, name, section=None):
1022
923
        """Set a per-branch configuration option"""
1023
924
        self.branch.lock_write()
1024
925
        try:
1025
 
            self._config.set_option(value, name, section)
 
926
            cfg_obj = self._get_config()
 
927
            if section is None:
 
928
                obj = cfg_obj
 
929
            else:
 
930
                try:
 
931
                    obj = cfg_obj[section]
 
932
                except KeyError:
 
933
                    cfg_obj[section] = {}
 
934
                    obj = cfg_obj[section]
 
935
            obj[name] = value
 
936
            out_file = StringIO()
 
937
            cfg_obj.write(out_file)
 
938
            out_file.seek(0)
 
939
            self.branch.control_files.put('branch.conf', out_file)
1026
940
        finally:
1027
941
            self.branch.unlock()
1028
942
 
1035
949
    """
1036
950
 
1037
951
    def __init__(self, _file=None):
 
952
        super(AuthenticationConfig, self).__init__()
1038
953
        self._config = None # The ConfigObj
1039
954
        if _file is None:
1040
 
            self._filename = authentication_config_filename()
1041
 
            self._input = self._filename = authentication_config_filename()
 
955
            self._get_filename = authentication_config_filename
 
956
            self._input = self._get_filename()
1042
957
        else:
1043
 
            # Tests can provide a string as _file
1044
 
            self._filename = None
 
958
            self._get_filename = None
1045
959
            self._input = _file
1046
960
 
1047
961
    def _get_config(self):
1048
962
        if self._config is not None:
1049
963
            return self._config
1050
964
        try:
1051
 
            # FIXME: Should we validate something here ? Includes: empty
1052
 
            # sections are useless, at least one of
1053
 
            # user/password/password_encoding should be defined, etc.
 
965
            # FIXME: Should we validate something here ? Includes: port must be
 
966
            # numeric, empty sections are useless, verify_certificates is
 
967
            # boolean, at least one of user/password/password_encoding should
 
968
            # be defined, etc.
1054
969
 
1055
970
            # Note: the encoding below declares that the file itself is utf-8
1056
971
            # encoded, but the values in the ConfigObj are always Unicode.
1061
976
 
1062
977
    def _save(self):
1063
978
        """Save the config file, only tests should use it for now."""
1064
 
        conf_dir = os.path.dirname(self._filename)
 
979
        file_name = self._get_filename()
 
980
        conf_dir = os.path.dirname(file_name)
1065
981
        ensure_config_dir_exists(conf_dir)
1066
 
        self._get_config().write(file(self._filename, 'wb'))
 
982
        self._get_config().write(file(file_name, 'wb'))
1067
983
 
1068
984
    def _set_option(self, section_name, option_name, value):
1069
985
        """Set an authentication configuration option"""
1075
991
        section[option_name] = value
1076
992
        self._save()
1077
993
 
1078
 
    def get_credentials(self, scheme, host, port=None, user=None, path=None, 
1079
 
                        realm=None):
 
994
    def get_credentials(self, scheme, host, port=None, user=None, path=None):
1080
995
        """Returns the matching credentials from authentication.conf file.
1081
996
 
1082
997
        :param scheme: protocol
1088
1003
        :param user: login (optional)
1089
1004
 
1090
1005
        :param path: the absolute path on the server (optional)
1091
 
        
1092
 
        :param realm: the http authentication realm (optional)
1093
1006
 
1094
1007
        :return: A dict containing the matching credentials or None.
1095
1008
           This includes:
1096
1009
           - name: the section name of the credentials in the
1097
1010
             authentication.conf file,
1098
 
           - user: can't be different from the provided user if any,
1099
 
           - scheme: the server protocol,
1100
 
           - host: the server address,
1101
 
           - port: the server port (can be None),
1102
 
           - path: the absolute server path (can be None),
1103
 
           - realm: the http specific authentication realm (can be None),
 
1011
           - user: can't de different from the provided user if any,
1104
1012
           - password: the decoded password, could be None if the credential
1105
1013
             defines only the user
1106
1014
           - verify_certificates: https specific, True if the server
1108
1016
        """
1109
1017
        credentials = None
1110
1018
        for auth_def_name, auth_def in self._get_config().items():
1111
 
            if type(auth_def) is not configobj.Section:
1112
 
                raise ValueError("%s defined outside a section" % auth_def_name)
1113
 
 
1114
1019
            a_scheme, a_host, a_user, a_path = map(
1115
1020
                auth_def.get, ['scheme', 'host', 'user', 'path'])
1116
1021
 
1118
1023
                a_port = auth_def.as_int('port')
1119
1024
            except KeyError:
1120
1025
                a_port = None
1121
 
            except ValueError:
1122
 
                raise ValueError("'port' not numeric in %s" % auth_def_name)
1123
1026
            try:
1124
1027
                a_verify_certificates = auth_def.as_bool('verify_certificates')
1125
1028
            except KeyError:
1126
1029
                a_verify_certificates = True
1127
 
            except ValueError:
1128
 
                raise ValueError(
1129
 
                    "'verify_certificates' not boolean in %s" % auth_def_name)
1130
1030
 
1131
1031
            # Attempt matching
1132
1032
            if a_scheme is not None and scheme != a_scheme:
1147
1047
            if a_user is None:
1148
1048
                # Can't find a user
1149
1049
                continue
1150
 
            # Prepare a credentials dictionary with additional keys
1151
 
            # for the credential providers
1152
 
            credentials = dict(name=auth_def_name,
1153
 
                               user=a_user,
1154
 
                               scheme=a_scheme,
1155
 
                               host=host,
1156
 
                               port=port,
1157
 
                               path=path,
1158
 
                               realm=realm,
1159
 
                               password=auth_def.get('password', None),
1160
 
                               verify_certificates=a_verify_certificates)
1161
 
            # Decode the password in the credentials (or get one)
1162
 
            self.decode_password(credentials,
1163
 
                                 auth_def.get('password_encoding', None))
 
1050
            a_password, a_encoding = map(auth_def.get,
 
1051
                                         ['password', 'password_encoding'])
 
1052
            password = self.decode_password(a_password, a_encoding)
 
1053
            credentials = {'name': auth_def_name,
 
1054
                           'user': a_user, 'password': password,
 
1055
                           'verify_certificates': a_verify_certificates,
 
1056
                           }
1164
1057
            if 'auth' in debug.debug_flags:
1165
1058
                trace.mutter("Using authentication section: %r", auth_def_name)
1166
1059
            break
1167
1060
 
1168
 
        if credentials is None:
1169
 
            # No credentials were found in authentication.conf, try the fallback
1170
 
            # credentials stores.
1171
 
            credentials = credential_store_registry.get_fallback_credentials(
1172
 
                scheme, host, port, user, path, realm)
1173
 
 
1174
1061
        return credentials
1175
1062
 
1176
 
    def set_credentials(self, name, host, user, scheme=None, password=None,
1177
 
                        port=None, path=None, verify_certificates=None,
1178
 
                        realm=None):
1179
 
        """Set authentication credentials for a host.
1180
 
 
1181
 
        Any existing credentials with matching scheme, host, port and path
1182
 
        will be deleted, regardless of name.
1183
 
 
1184
 
        :param name: An arbitrary name to describe this set of credentials.
1185
 
        :param host: Name of the host that accepts these credentials.
1186
 
        :param user: The username portion of these credentials.
1187
 
        :param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1188
 
            to.
1189
 
        :param password: Password portion of these credentials.
1190
 
        :param port: The IP port on the host that these credentials apply to.
1191
 
        :param path: A filesystem path on the host that these credentials
1192
 
            apply to.
1193
 
        :param verify_certificates: On https, verify server certificates if
1194
 
            True.
1195
 
        :param realm: The http authentication realm (optional).
1196
 
        """
1197
 
        values = {'host': host, 'user': user}
1198
 
        if password is not None:
1199
 
            values['password'] = password
1200
 
        if scheme is not None:
1201
 
            values['scheme'] = scheme
1202
 
        if port is not None:
1203
 
            values['port'] = '%d' % port
1204
 
        if path is not None:
1205
 
            values['path'] = path
1206
 
        if verify_certificates is not None:
1207
 
            values['verify_certificates'] = str(verify_certificates)
1208
 
        if realm is not None:
1209
 
            values['realm'] = realm
1210
 
        config = self._get_config()
1211
 
        for_deletion = []
1212
 
        for section, existing_values in config.items():
1213
 
            for key in ('scheme', 'host', 'port', 'path', 'realm'):
1214
 
                if existing_values.get(key) != values.get(key):
1215
 
                    break
1216
 
            else:
1217
 
                del config[section]
1218
 
        config.update({name: values})
1219
 
        self._save()
1220
 
 
1221
 
    def get_user(self, scheme, host, port=None, realm=None, path=None,
1222
 
                 prompt=None, ask=False, default=None):
 
1063
    def get_user(self, scheme, host, port=None,
 
1064
                 realm=None, path=None, prompt=None):
1223
1065
        """Get a user from authentication file.
1224
1066
 
1225
1067
        :param scheme: protocol
1232
1074
 
1233
1075
        :param path: the absolute path on the server (optional)
1234
1076
 
1235
 
        :param ask: Ask the user if there is no explicitly configured username 
1236
 
                    (optional)
1237
 
 
1238
 
        :param default: The username returned if none is defined (optional).
1239
 
 
1240
1077
        :return: The found user.
1241
1078
        """
1242
1079
        credentials = self.get_credentials(scheme, host, port, user=None,
1243
 
                                           path=path, realm=realm)
 
1080
                                           path=path)
1244
1081
        if credentials is not None:
1245
1082
            user = credentials['user']
1246
1083
        else:
1247
1084
            user = None
1248
 
        if user is None:
1249
 
            if ask:
1250
 
                if prompt is None:
1251
 
                    # Create a default prompt suitable for most cases
1252
 
                    prompt = scheme.upper() + ' %(host)s username'
1253
 
                # Special handling for optional fields in the prompt
1254
 
                if port is not None:
1255
 
                    prompt_host = '%s:%d' % (host, port)
1256
 
                else:
1257
 
                    prompt_host = host
1258
 
                user = ui.ui_factory.get_username(prompt, host=prompt_host)
1259
 
            else:
1260
 
                user = default
1261
1085
        return user
1262
1086
 
1263
1087
    def get_password(self, scheme, host, user, port=None,
1278
1102
 
1279
1103
        :return: The found password or the one entered by the user.
1280
1104
        """
1281
 
        credentials = self.get_credentials(scheme, host, port, user, path,
1282
 
                                           realm)
 
1105
        credentials = self.get_credentials(scheme, host, port, user, path)
1283
1106
        if credentials is not None:
1284
1107
            password = credentials['password']
1285
 
            if password is not None and scheme is 'ssh':
1286
 
                trace.warning('password ignored in section [%s],'
1287
 
                              ' use an ssh agent instead'
1288
 
                              % credentials['name'])
1289
 
                password = None
1290
1108
        else:
1291
1109
            password = None
1292
 
        # Prompt user only if we could't find a password
1293
1110
        if password is None:
 
1111
            # Prompt user only if we could't find a password
1294
1112
            if prompt is None:
1295
 
                # Create a default prompt suitable for most cases
1296
 
                prompt = '%s' % scheme.upper() + ' %(user)s@%(host)s password'
 
1113
                prompt = ('%s' % scheme.upper()
 
1114
                          + ' %(user)s@%(host)s%(realm)s password')
1297
1115
            # Special handling for optional fields in the prompt
1298
1116
            if port is not None:
1299
1117
                prompt_host = '%s:%d' % (host, port)
1300
1118
            else:
1301
1119
                prompt_host = host
1302
 
            password = ui.ui_factory.get_password(prompt,
1303
 
                                                  host=prompt_host, user=user)
1304
 
        return password
1305
 
 
1306
 
    def decode_password(self, credentials, encoding):
1307
 
        try:
1308
 
            cs = credential_store_registry.get_credential_store(encoding)
1309
 
        except KeyError:
1310
 
            raise ValueError('%r is not a known password_encoding' % encoding)
1311
 
        credentials['password'] = cs.decode_password(credentials)
1312
 
        return credentials
1313
 
 
1314
 
 
1315
 
class CredentialStoreRegistry(registry.Registry):
1316
 
    """A class that registers credential stores.
1317
 
 
1318
 
    A credential store provides access to credentials via the password_encoding
1319
 
    field in authentication.conf sections.
1320
 
 
1321
 
    Except for stores provided by bzr itself, most stores are expected to be
1322
 
    provided by plugins that will therefore use
1323
 
    register_lazy(password_encoding, module_name, member_name, help=help,
1324
 
    fallback=fallback) to install themselves.
1325
 
 
1326
 
    A fallback credential store is one that is queried if no credentials can be
1327
 
    found via authentication.conf.
1328
 
    """
1329
 
 
1330
 
    def get_credential_store(self, encoding=None):
1331
 
        cs = self.get(encoding)
1332
 
        if callable(cs):
1333
 
            cs = cs()
1334
 
        return cs
1335
 
 
1336
 
    def is_fallback(self, name):
1337
 
        """Check if the named credentials store should be used as fallback."""
1338
 
        return self.get_info(name)
1339
 
 
1340
 
    def get_fallback_credentials(self, scheme, host, port=None, user=None,
1341
 
                                 path=None, realm=None):
1342
 
        """Request credentials from all fallback credentials stores.
1343
 
 
1344
 
        The first credentials store that can provide credentials wins.
1345
 
        """
1346
 
        credentials = None
1347
 
        for name in self.keys():
1348
 
            if not self.is_fallback(name):
1349
 
                continue
1350
 
            cs = self.get_credential_store(name)
1351
 
            credentials = cs.get_credentials(scheme, host, port, user,
1352
 
                                             path, realm)
1353
 
            if credentials is not None:
1354
 
                # We found some credentials
1355
 
                break
1356
 
        return credentials
1357
 
 
1358
 
    def register(self, key, obj, help=None, override_existing=False,
1359
 
                 fallback=False):
1360
 
        """Register a new object to a name.
1361
 
 
1362
 
        :param key: This is the key to use to request the object later.
1363
 
        :param obj: The object to register.
1364
 
        :param help: Help text for this entry. This may be a string or
1365
 
                a callable. If it is a callable, it should take two
1366
 
                parameters (registry, key): this registry and the key that
1367
 
                the help was registered under.
1368
 
        :param override_existing: Raise KeyErorr if False and something has
1369
 
                already been registered for that key. If True, ignore if there
1370
 
                is an existing key (always register the new value).
1371
 
        :param fallback: Whether this credential store should be 
1372
 
                used as fallback.
1373
 
        """
1374
 
        return super(CredentialStoreRegistry,
1375
 
                     self).register(key, obj, help, info=fallback,
1376
 
                                    override_existing=override_existing)
1377
 
 
1378
 
    def register_lazy(self, key, module_name, member_name,
1379
 
                      help=None, override_existing=False,
1380
 
                      fallback=False):
1381
 
        """Register a new credential store to be loaded on request.
1382
 
 
1383
 
        :param module_name: The python path to the module. Such as 'os.path'.
1384
 
        :param member_name: The member of the module to return.  If empty or
1385
 
                None, get() will return the module itself.
1386
 
        :param help: Help text for this entry. This may be a string or
1387
 
                a callable.
1388
 
        :param override_existing: If True, replace the existing object
1389
 
                with the new one. If False, if there is already something
1390
 
                registered with the same key, raise a KeyError
1391
 
        :param fallback: Whether this credential store should be 
1392
 
                used as fallback.
1393
 
        """
1394
 
        return super(CredentialStoreRegistry, self).register_lazy(
1395
 
            key, module_name, member_name, help,
1396
 
            info=fallback, override_existing=override_existing)
1397
 
 
1398
 
 
1399
 
credential_store_registry = CredentialStoreRegistry()
1400
 
 
1401
 
 
1402
 
class CredentialStore(object):
1403
 
    """An abstract class to implement storage for credentials"""
1404
 
 
1405
 
    def decode_password(self, credentials):
1406
 
        """Returns a clear text password for the provided credentials."""
1407
 
        raise NotImplementedError(self.decode_password)
1408
 
 
1409
 
    def get_credentials(self, scheme, host, port=None, user=None, path=None,
1410
 
                        realm=None):
1411
 
        """Return the matching credentials from this credential store.
1412
 
 
1413
 
        This method is only called on fallback credential stores.
1414
 
        """
1415
 
        raise NotImplementedError(self.get_credentials)
1416
 
 
1417
 
 
1418
 
 
1419
 
class PlainTextCredentialStore(CredentialStore):
1420
 
    __doc__ = """Plain text credential store for the authentication.conf file"""
1421
 
 
1422
 
    def decode_password(self, credentials):
1423
 
        """See CredentialStore.decode_password."""
1424
 
        return credentials['password']
1425
 
 
1426
 
 
1427
 
credential_store_registry.register('plain', PlainTextCredentialStore,
1428
 
                                   help=PlainTextCredentialStore.__doc__)
1429
 
credential_store_registry.default_key = 'plain'
1430
 
 
1431
 
 
1432
 
class BzrDirConfig(object):
1433
 
 
1434
 
    def __init__(self, bzrdir):
1435
 
        self._bzrdir = bzrdir
1436
 
        self._config = bzrdir._get_config()
1437
 
 
1438
 
    def set_default_stack_on(self, value):
1439
 
        """Set the default stacking location.
1440
 
 
1441
 
        It may be set to a location, or None.
1442
 
 
1443
 
        This policy affects all branches contained by this bzrdir, except for
1444
 
        those under repositories.
1445
 
        """
1446
 
        if self._config is None:
1447
 
            raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
1448
 
        if value is None:
1449
 
            self._config.set_option('', 'default_stack_on')
1450
 
        else:
1451
 
            self._config.set_option(value, 'default_stack_on')
1452
 
 
1453
 
    def get_default_stack_on(self):
1454
 
        """Return the default stacking location.
1455
 
 
1456
 
        This will either be a location, or None.
1457
 
 
1458
 
        This policy affects all branches contained by this bzrdir, except for
1459
 
        those under repositories.
1460
 
        """
1461
 
        if self._config is None:
1462
 
            return None
1463
 
        value = self._config.get_option('default_stack_on')
1464
 
        if value == '':
1465
 
            value = None
1466
 
        return value
1467
 
 
1468
 
 
1469
 
class TransportConfig(object):
1470
 
    """A Config that reads/writes a config file on a Transport.
1471
 
 
1472
 
    It is a low-level object that considers config data to be name/value pairs
1473
 
    that may be associated with a section.  Assigning meaning to the these
1474
 
    values is done at higher levels like TreeConfig.
1475
 
    """
1476
 
 
1477
 
    def __init__(self, transport, filename):
1478
 
        self._transport = transport
1479
 
        self._filename = filename
1480
 
 
1481
 
    def get_option(self, name, section=None, default=None):
1482
 
        """Return the value associated with a named option.
1483
 
 
1484
 
        :param name: The name of the value
1485
 
        :param section: The section the option is in (if any)
1486
 
        :param default: The value to return if the value is not set
1487
 
        :return: The value or default value
1488
 
        """
1489
 
        configobj = self._get_configobj()
1490
 
        if section is None:
1491
 
            section_obj = configobj
1492
 
        else:
1493
 
            try:
1494
 
                section_obj = configobj[section]
1495
 
            except KeyError:
1496
 
                return default
1497
 
        return section_obj.get(name, default)
1498
 
 
1499
 
    def set_option(self, value, name, section=None):
1500
 
        """Set the value associated with a named option.
1501
 
 
1502
 
        :param value: The value to set
1503
 
        :param name: The name of the value to set
1504
 
        :param section: The section the option is in (if any)
1505
 
        """
1506
 
        configobj = self._get_configobj()
1507
 
        if section is None:
1508
 
            configobj[name] = value
1509
 
        else:
1510
 
            configobj.setdefault(section, {})[name] = value
1511
 
        self._set_configobj(configobj)
1512
 
 
1513
 
    def _get_config_file(self):
1514
 
        try:
1515
 
            return StringIO(self._transport.get_bytes(self._filename))
1516
 
        except errors.NoSuchFile:
1517
 
            return StringIO()
1518
 
 
1519
 
    def _get_configobj(self):
1520
 
        return ConfigObj(self._get_config_file(), encoding='utf-8')
1521
 
 
1522
 
    def _set_configobj(self, configobj):
1523
 
        out_file = StringIO()
1524
 
        configobj.write(out_file)
1525
 
        out_file.seek(0)
1526
 
        self._transport.put_file(self._filename, out_file)
 
1120
            if realm is not None:
 
1121
                prompt_realm = ", Realm: '%s'" % realm
 
1122
            else:
 
1123
                prompt_realm = ''
 
1124
            password = ui.ui_factory.get_password(prompt, host=prompt_host,
 
1125
                                                  user=user,
 
1126
                                                  realm=prompt_realm)
 
1127
        return password
 
1128
 
 
1129
    def decode_password(self, password, encoding):
 
1130
        return password