/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: 2009-07-13 06:58:49 UTC
  • mto: (4527.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4529.
  • Revision ID: ian.clatworthy@canonical.com-20090713065849-n7g2rsjyl6dt1mgv
Apply review feedback

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2007, 2008 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#            and others
4
4
#
146
146
class Config(object):
147
147
    """A configuration policy - what username, editor, gpg needs etc."""
148
148
 
149
 
    def __init__(self):
150
 
        super(Config, self).__init__()
151
 
 
152
149
    def get_editor(self):
153
150
        """Get the users pop up editor."""
154
151
        raise NotImplementedError
155
152
 
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
153
    def get_mail_client(self):
166
154
        """Get a mail client to use"""
167
155
        selected_client = self.get_user_option('mail_client')
186
174
        """Get a generic option - no special process, no default."""
187
175
        return self._get_user_option(option_name)
188
176
 
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
177
    def gpg_signing_command(self):
219
178
        """What program should be used to sign signatures?"""
220
179
        result = self._gpg_signing_command()
237
196
        """See log_format()."""
238
197
        return None
239
198
 
 
199
    def __init__(self):
 
200
        super(Config, self).__init__()
 
201
 
240
202
    def post_commit(self):
241
203
        """An ordered list of python functions to call.
242
204
 
257
219
 
258
220
        Something similar to 'Martin Pool <mbp@sourcefrog.net>'
259
221
 
260
 
        $BZR_EMAIL can be set to override this, then
 
222
        $BZR_EMAIL can be set to override this (as well as the
 
223
        deprecated $BZREMAIL), then
261
224
        the concrete policy type is checked, and finally
262
225
        $EMAIL is examined.
263
 
        If no username can be found, errors.NoWhoami exception is raised.
 
226
        If none is found, a reasonable default is (hopefully)
 
227
        created.
264
228
 
265
229
        TODO: Check it's reasonably well-formed.
266
230
        """
276
240
        if v:
277
241
            return v.decode(osutils.get_user_encoding())
278
242
 
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()
 
243
        name, email = _auto_user_id()
 
244
        if name:
 
245
            return '%s <%s>' % (name, email)
 
246
        else:
 
247
            return email
287
248
 
288
249
    def signature_checking(self):
289
250
        """What is the current policy for signature checking?."""
334
295
                path = 'bzr'
335
296
            return path
336
297
 
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
298
 
351
299
class IniBasedConfig(Config):
352
300
    """A configuration policy that draws from ini files."""
353
301
 
354
 
    def __init__(self, get_filename):
355
 
        super(IniBasedConfig, self).__init__()
356
 
        self._get_filename = get_filename
357
 
        self._parser = None
358
 
 
359
302
    def _get_parser(self, file=None):
360
303
        if self._parser is not None:
361
304
            return self._parser
389
332
        """Return the policy for the given (section, option_name) pair."""
390
333
        return POLICY_NONE
391
334
 
392
 
    def _get_change_editor(self):
393
 
        return self.get_user_option('change_editor')
394
 
 
395
335
    def _get_signature_checking(self):
396
336
        """See Config._get_signature_checking."""
397
337
        policy = self._get_user_option('check_signatures')
441
381
        """See Config.log_format."""
442
382
        return self._get_user_option('log_format')
443
383
 
 
384
    def __init__(self, get_filename):
 
385
        super(IniBasedConfig, self).__init__()
 
386
        self._get_filename = get_filename
 
387
        self._parser = None
 
388
 
444
389
    def _post_commit(self):
445
390
        """See Config.post_commit."""
446
391
        return self._get_user_option('post_commit')
477
422
    def _get_nickname(self):
478
423
        return self.get_user_option('nickname')
479
424
 
480
 
    def _write_config_file(self):
481
 
        f = file(self._get_filename(), "wb")
482
 
        try:
483
 
            osutils.copy_ownership_from_path(f.name)
484
 
            self._get_parser().write(f)
485
 
        finally:
486
 
            f.close()
487
 
 
488
425
 
489
426
class GlobalConfig(IniBasedConfig):
490
427
    """The configuration that should be used for a specific location."""
526
463
        self._get_parser().setdefault(section, {})[option] = value
527
464
        self._write_config_file()
528
465
 
 
466
    def _write_config_file(self):
 
467
        f = open(self._get_filename(), 'wb')
 
468
        self._get_parser().write(f)
 
469
        f.close()
 
470
 
529
471
 
530
472
class LocationConfig(IniBasedConfig):
531
473
    """A configuration object that gives the policy for a location."""
665
607
        self._get_parser()[location][option]=value
666
608
        # the allowed values of store match the config policies
667
609
        self._set_option_policy(location, option, store)
668
 
        self._write_config_file()
 
610
        self._get_parser().write(file(self._get_filename(), 'wb'))
669
611
 
670
612
 
671
613
class BranchConfig(Config):
728
670
 
729
671
        return self._get_best_value('_get_user_id')
730
672
 
731
 
    def _get_change_editor(self):
732
 
        return self._get_best_value('_get_change_editor')
733
 
 
734
673
    def _get_signature_checking(self):
735
674
        """See Config._get_signature_checking."""
736
675
        return self._get_best_value('_get_signature_checking')
822
761
            os.mkdir(parent_dir)
823
762
        trace.mutter('creating config directory: %r', path)
824
763
        os.mkdir(path)
825
 
        osutils.copy_ownership_from_path(path)
826
764
 
827
765
 
828
766
def config_dir():
843
781
                                  ' or HOME set')
844
782
        return osutils.pathjoin(base, 'bazaar', '2.0')
845
783
    else:
 
784
        # cygwin, linux, and darwin all have a $HOME directory
846
785
        if base is None:
847
786
            base = os.path.expanduser("~")
848
787
        return osutils.pathjoin(base, ".bazaar")
873
812
    return osutils.pathjoin(config_dir(), 'ignore')
874
813
 
875
814
 
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.
 
815
def _auto_user_id():
 
816
    """Calculate automatic user identification.
 
817
 
 
818
    Returns (realname, email).
 
819
 
 
820
    Only used when none is set in the environment or the id file.
 
821
 
 
822
    This previously used the FQDN as the default domain, but that can
 
823
    be very slow on machines where DNS is broken.  So now we simply
 
824
    use the hostname.
884
825
    """
 
826
    import socket
 
827
 
885
828
    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')
 
829
        name = win32utils.get_user_name_unicode()
 
830
        if name is None:
 
831
            raise errors.BzrError("Cannot autodetect user name.\n"
 
832
                                  "Please, set your name with command like:\n"
 
833
                                  'bzr whoami "Your Name <name@domain.com>"')
 
834
        host = win32utils.get_host_name_unicode()
 
835
        if host is None:
 
836
            host = socket.gethostname()
 
837
        return name, (name + '@' + host)
 
838
 
 
839
    try:
 
840
        import pwd
 
841
        uid = os.getuid()
 
842
        try:
 
843
            w = pwd.getpwuid(uid)
 
844
        except KeyError:
 
845
            raise errors.BzrCommandError('Unable to determine your name.  '
 
846
                'Please use "bzr whoami" to set it.')
 
847
 
 
848
        # we try utf-8 first, because on many variants (like Linux),
 
849
        # /etc/passwd "should" be in utf-8, and because it's unlikely to give
 
850
        # false positives.  (many users will have their user encoding set to
 
851
        # latin-1, which cannot raise UnicodeError.)
 
852
        try:
 
853
            gecos = w.pw_gecos.decode('utf-8')
 
854
            encoding = 'utf-8'
 
855
        except UnicodeError:
 
856
            try:
 
857
                encoding = osutils.get_user_encoding()
 
858
                gecos = w.pw_gecos.decode(encoding)
 
859
            except UnicodeError:
 
860
                raise errors.BzrCommandError('Unable to determine your name.  '
 
861
                   'Use "bzr whoami" to set it.')
 
862
        try:
 
863
            username = w.pw_name.decode(encoding)
 
864
        except UnicodeError:
 
865
            raise errors.BzrCommandError('Unable to determine your name.  '
 
866
                'Use "bzr whoami" to set it.')
 
867
 
 
868
        comma = gecos.find(',')
 
869
        if comma == -1:
 
870
            realname = gecos
 
871
        else:
 
872
            realname = gecos[:comma]
 
873
        if not realname:
 
874
            realname = username
 
875
 
 
876
    except ImportError:
 
877
        import getpass
 
878
        try:
 
879
            user_encoding = osutils.get_user_encoding()
 
880
            realname = username = getpass.getuser().decode(user_encoding)
 
881
        except UnicodeDecodeError:
 
882
            raise errors.BzrError("Can't decode username as %s." % \
 
883
                    user_encoding)
 
884
 
 
885
    return realname, (username + '@' + socket.gethostname())
901
886
 
902
887
 
903
888
def parse_username(username):
991
976
        """Save the config file, only tests should use it for now."""
992
977
        conf_dir = os.path.dirname(self._filename)
993
978
        ensure_config_dir_exists(conf_dir)
994
 
        f = file(self._filename, 'wb')
995
 
        try:
996
 
            self._get_config().write(f)
997
 
        finally:
998
 
            f.close()
 
979
        self._get_config().write(file(self._filename, 'wb'))
999
980
 
1000
981
    def _set_option(self, section_name, option_name, value):
1001
982
        """Set an authentication configuration option"""
1349
1330
 
1350
1331
 
1351
1332
class PlainTextCredentialStore(CredentialStore):
1352
 
    __doc__ = """Plain text credential store for the authentication.conf file"""
 
1333
    """Plain text credential store for the authentication.conf file."""
1353
1334
 
1354
1335
    def decode_password(self, credentials):
1355
1336
        """See CredentialStore.decode_password."""
1444
1425
 
1445
1426
    def _get_config_file(self):
1446
1427
        try:
1447
 
            return StringIO(self._transport.get_bytes(self._filename))
 
1428
            return self._transport.get(self._filename)
1448
1429
        except errors.NoSuchFile:
1449
1430
            return StringIO()
1450
1431
 
1451
1432
    def _get_configobj(self):
1452
 
        f = self._get_config_file()
1453
 
        try:
1454
 
            return ConfigObj(f, encoding='utf-8')
1455
 
        finally:
1456
 
            f.close()
 
1433
        return ConfigObj(self._get_config_file(), encoding='utf-8')
1457
1434
 
1458
1435
    def _set_configobj(self, configobj):
1459
1436
        out_file = StringIO()