350
361
class IniBasedConfig(Config):
351
362
"""A configuration policy that draws from ini files."""
353
def __init__(self, get_filename):
364
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
366
"""Base class for configuration files using an ini-like syntax.
368
:param file_name: The configuration file path.
354
370
super(IniBasedConfig, self).__init__()
355
self._get_filename = get_filename
371
self.file_name = file_name
372
if symbol_versioning.deprecated_passed(get_filename):
373
symbol_versioning.warn(
374
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
375
' Use file_name instead.',
378
if get_filename is not None:
379
self.file_name = get_filename()
381
self.file_name = file_name
356
383
self._parser = None
358
def _get_parser(self, file=None):
386
def from_string(cls, str_or_unicode, file_name=None, save=False):
387
"""Create a config object from a string.
389
:param str_or_unicode: A string representing the file content. This will
392
:param file_name: The configuration file path.
394
:param _save: Whether the file should be saved upon creation.
396
conf = cls(file_name=file_name)
397
conf._create_from_string(str_or_unicode, save)
400
def _create_from_string(self, str_or_unicode, save):
401
self._content = StringIO(str_or_unicode.encode('utf-8'))
402
# Some tests use in-memory configs, some other always need the config
403
# file to exist on disk.
405
self._write_config_file()
407
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
359
408
if self._parser is not None:
360
409
return self._parser
362
input = self._get_filename()
410
if symbol_versioning.deprecated_passed(file):
411
symbol_versioning.warn(
412
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
413
' Use IniBasedConfig(_content=xxx) instead.',
416
if self._content is not None:
417
co_input = self._content
418
elif self.file_name is None:
419
raise AssertionError('We have no content to create the config')
421
co_input = self.file_name
366
self._parser = ConfigObj(input, encoding='utf-8')
423
self._parser = ConfigObj(co_input, encoding='utf-8')
367
424
except configobj.ConfigObjError, e:
368
425
raise errors.ParseConfigError(e.errors, e.config.filename)
426
# Make sure self.reload() will use the right file name
427
self._parser.filename = self.file_name
369
428
return self._parser
431
"""Reload the config file from disk."""
432
if self.file_name is None:
433
raise AssertionError('We need a file name to reload the config')
434
if self._parser is not None:
435
self._parser.reload()
371
437
def _get_matching_sections(self):
372
438
"""Return an ordered list of (section_name, extra_path) pairs.
384
450
"""Override this to define the section used by the config."""
453
def _get_sections(self, name=None):
454
"""Returns an iterator of the sections specified by ``name``.
456
:param name: The section name. If None is supplied, the default
457
configurations are yielded.
459
:return: A tuple (name, section, config_id) for all sections that will
460
be walked by user_get_option() in the 'right' order. The first one
461
is where set_user_option() will update the value.
463
parser = self._get_parser()
465
yield (name, parser[name], self.config_id())
467
# No section name has been given so we fallback to the configobj
468
# itself which holds the variables defined outside of any section.
469
yield (None, parser, self.config_id())
471
def _get_options(self, sections=None):
472
"""Return an ordered list of (name, value, section, config_id) tuples.
474
All options are returned with their associated value and the section
475
they appeared in. ``config_id`` is a unique identifier for the
476
configuration file the option is defined in.
478
:param sections: Default to ``_get_matching_sections`` if not
479
specified. This gives a better control to daughter classes about
480
which sections should be searched. This is a list of (name,
485
parser = self._get_parser()
487
for (section_name, _) in self._get_matching_sections():
489
section = parser[section_name]
491
# This could happen for an empty file for which we define a
492
# DEFAULT section. FIXME: Force callers to provide sections
493
# instead ? -- vila 20100930
495
sections.append((section_name, section))
496
config_id = self.config_id()
497
for (section_name, section) in sections:
498
for (name, value) in section.iteritems():
499
yield (name, parser._quote(value), section_name,
387
502
def _get_option_policy(self, section, option_name):
388
503
"""Return the policy for the given (section, option_name) pair."""
389
504
return POLICY_NONE
476
591
def _get_nickname(self):
477
592
return self.get_user_option('nickname')
480
class GlobalConfig(IniBasedConfig):
594
def remove_user_option(self, option_name, section_name=None):
595
"""Remove a user option and save the configuration file.
597
:param option_name: The option to be removed.
599
:param section_name: The section the option is defined in, default to
603
parser = self._get_parser()
604
if section_name is None:
607
section = parser[section_name]
609
del section[option_name]
611
raise errors.NoSuchConfigOption(option_name)
612
self._write_config_file()
614
def _write_config_file(self):
615
if self.file_name is None:
616
raise AssertionError('We cannot save, self.file_name is None')
617
conf_dir = os.path.dirname(self.file_name)
618
ensure_config_dir_exists(conf_dir)
619
atomic_file = atomicfile.AtomicFile(self.file_name)
620
self._get_parser().write(atomic_file)
623
osutils.copy_ownership_from_path(self.file_name)
626
class LockableConfig(IniBasedConfig):
627
"""A configuration needing explicit locking for access.
629
If several processes try to write the config file, the accesses need to be
632
Daughter classes should decorate all methods that update a config with the
633
``@needs_write_lock`` decorator (they call, directly or indirectly, the
634
``_write_config_file()`` method. These methods (typically ``set_option()``
635
and variants must reload the config file from disk before calling
636
``_write_config_file()``), this can be achieved by calling the
637
``self.reload()`` method. Note that the lock scope should cover both the
638
reading and the writing of the config file which is why the decorator can't
639
be applied to ``_write_config_file()`` only.
641
This should be enough to implement the following logic:
642
- lock for exclusive write access,
643
- reload the config file from disk,
647
This logic guarantees that a writer can update a value without erasing an
648
update made by another writer.
653
def __init__(self, file_name):
654
super(LockableConfig, self).__init__(file_name=file_name)
655
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
656
self.transport = transport.get_transport(self.dir)
657
self._lock = lockdir.LockDir(self.transport, 'lock')
659
def _create_from_string(self, unicode_bytes, save):
660
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
662
# We need to handle the saving here (as opposed to IniBasedConfig)
665
self._write_config_file()
668
def lock_write(self, token=None):
669
"""Takes a write lock in the directory containing the config file.
671
If the directory doesn't exist it is created.
673
ensure_config_dir_exists(self.dir)
674
return self._lock.lock_write(token)
679
def break_lock(self):
680
self._lock.break_lock()
683
def remove_user_option(self, option_name, section_name=None):
684
super(LockableConfig, self).remove_user_option(option_name,
687
def _write_config_file(self):
688
if self._lock is None or not self._lock.is_held:
689
# NB: if the following exception is raised it probably means a
690
# missing @needs_write_lock decorator on one of the callers.
691
raise errors.ObjectNotLocked(self)
692
super(LockableConfig, self)._write_config_file()
695
class GlobalConfig(LockableConfig):
481
696
"""The configuration that should be used for a specific location."""
699
super(GlobalConfig, self).__init__(file_name=config_filename())
705
def from_string(cls, str_or_unicode, save=False):
706
"""Create a config object from a string.
708
:param str_or_unicode: A string representing the file content. This
709
will be utf-8 encoded.
711
:param save: Whether the file should be saved upon creation.
714
conf._create_from_string(str_or_unicode, save)
483
717
def get_editor(self):
484
718
return self._get_user_option('editor')
487
super(GlobalConfig, self).__init__(config_filename)
489
721
def set_user_option(self, option, value):
490
722
"""Save option and its value in the configuration."""
491
723
self._set_option(option, value, 'DEFAULT')
510
745
self._write_config_file()
512
747
def _set_option(self, option, value, section):
513
# FIXME: RBC 20051029 This should refresh the parser and also take a
514
# file lock on bazaar.conf.
515
conf_dir = os.path.dirname(self._get_filename())
516
ensure_config_dir_exists(conf_dir)
517
749
self._get_parser().setdefault(section, {})[option] = value
518
750
self._write_config_file()
520
def _write_config_file(self):
521
path = self._get_filename()
523
osutils.copy_ownership_from_path(path)
524
self._get_parser().write(f)
528
class LocationConfig(IniBasedConfig):
753
def _get_sections(self, name=None):
754
"""See IniBasedConfig._get_sections()."""
755
parser = self._get_parser()
756
# We don't give access to options defined outside of any section, we
757
# used the DEFAULT section by... default.
758
if name in (None, 'DEFAULT'):
759
# This could happen for an empty file where the DEFAULT section
760
# doesn't exist yet. So we force DEFAULT when yielding
762
if 'DEFAULT' not in parser:
763
parser['DEFAULT']= {}
764
yield (name, parser[name], self.config_id())
767
def remove_user_option(self, option_name, section_name=None):
768
if section_name is None:
769
# We need to force the default section.
770
section_name = 'DEFAULT'
771
# We need to avoid the LockableConfig implementation or we'll lock
773
super(LockableConfig, self).remove_user_option(option_name,
777
class LocationConfig(LockableConfig):
529
778
"""A configuration object that gives the policy for a location."""
531
780
def __init__(self, location):
532
name_generator = locations_config_filename
533
if (not os.path.exists(name_generator()) and
534
os.path.exists(branches_config_filename())):
535
if sys.platform == 'win32':
536
trace.warning('Please rename %s to %s'
537
% (branches_config_filename(),
538
locations_config_filename()))
540
trace.warning('Please rename ~/.bazaar/branches.conf'
541
' to ~/.bazaar/locations.conf')
542
name_generator = branches_config_filename
543
super(LocationConfig, self).__init__(name_generator)
781
super(LocationConfig, self).__init__(
782
file_name=locations_config_filename())
544
783
# local file locations are looked up by local path, rather than
545
784
# by file url. This is because the config file is a user
546
785
# file, and we would rather not expose the user to file urls.
648
915
STORE_LOCATION_APPENDPATH]:
649
916
raise ValueError('bad storage policy %r for %r' %
651
# FIXME: RBC 20051029 This should refresh the parser and also take a
652
# file lock on locations.conf.
653
conf_dir = os.path.dirname(self._get_filename())
654
ensure_config_dir_exists(conf_dir)
655
919
location = self.location
656
920
if location.endswith('/'):
657
921
location = location[:-1]
658
if (not location in self._get_parser() and
659
not location + '/' in self._get_parser()):
660
self._get_parser()[location]={}
661
elif location + '/' in self._get_parser():
922
parser = self._get_parser()
923
if not location in parser and not location + '/' in parser:
924
parser[location] = {}
925
elif location + '/' in parser:
662
926
location = location + '/'
663
self._get_parser()[location][option]=value
927
parser[location][option]=value
664
928
# the allowed values of store match the config policies
665
929
self._set_option_policy(location, option, store)
666
self._get_parser().write(file(self._get_filename(), 'wb'))
930
self._write_config_file()
669
933
class BranchConfig(Config):
670
934
"""A configuration object giving the policy for a branch."""
936
def __init__(self, branch):
937
super(BranchConfig, self).__init__()
938
self._location_config = None
939
self._branch_data_config = None
940
self._global_config = None
942
self.option_sources = (self._get_location_config,
943
self._get_branch_data_config,
944
self._get_global_config)
672
949
def _get_branch_data_config(self):
673
950
if self._branch_data_config is None:
674
951
self._branch_data_config = TreeConfig(self.branch)
952
self._branch_data_config.config_id = self.config_id
675
953
return self._branch_data_config
677
955
def _get_location_config(self):
1026
def _get_sections(self, name=None):
1027
"""See IniBasedConfig.get_sections()."""
1028
for source in self.option_sources:
1029
for section in source()._get_sections(name):
1032
def _get_options(self, sections=None):
1034
# First the locations options
1035
for option in self._get_location_config()._get_options():
1037
# Then the branch options
1038
branch_config = self._get_branch_data_config()
1039
if sections is None:
1040
sections = [('DEFAULT', branch_config._get_parser())]
1041
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1042
# Config itself has no notion of sections :( -- vila 20101001
1043
config_id = self.config_id()
1044
for (section_name, section) in sections:
1045
for (name, value) in section.iteritems():
1046
yield (name, value, section_name,
1047
config_id, branch_config._get_parser())
1048
# Then the global options
1049
for option in self._get_global_config()._get_options():
748
1052
def set_user_option(self, name, value, store=STORE_BRANCH,
749
1053
warn_masked=False):
750
1054
if store == STORE_BRANCH:
826
1123
def config_dir():
827
1124
"""Return per-user configuration directory.
829
By default this is ~/.bazaar/
1126
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1127
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1128
that will be used instead.
831
1130
TODO: Global option --config-dir to override this.
833
1132
base = os.environ.get('BZR_HOME', None)
834
1133
if sys.platform == 'win32':
1134
# environ variables on Windows are in user encoding/mbcs. So decode
1136
if base is not None:
1137
base = base.decode('mbcs')
835
1138
if base is None:
836
1139
base = win32utils.get_appdata_location_unicode()
837
1140
if base is None:
838
1141
base = os.environ.get('HOME', None)
1142
if base is not None:
1143
base = base.decode('mbcs')
839
1144
if base is None:
840
1145
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
842
1147
return osutils.pathjoin(base, 'bazaar', '2.0')
1148
elif sys.platform == 'darwin':
1150
# this takes into account $HOME
1151
base = os.path.expanduser("~")
1152
return osutils.pathjoin(base, '.bazaar')
844
# cygwin, linux, and darwin all have a $HOME directory
845
1154
if base is None:
1156
xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1158
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1159
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1160
if osutils.isdir(xdg_dir):
1162
"Using configuration in XDG directory %s." % xdg_dir)
846
1165
base = os.path.expanduser("~")
847
1166
return osutils.pathjoin(base, ".bazaar")
899
1213
return os.path.expanduser('~/.cache')
903
"""Calculate automatic user identification.
905
Returns (realname, email).
907
Only used when none is set in the environment or the id file.
909
This previously used the FQDN as the default domain, but that can
910
be very slow on machines where DNS is broken. So now we simply
915
if sys.platform == 'win32':
916
name = win32utils.get_user_name_unicode()
918
raise errors.BzrError("Cannot autodetect user name.\n"
919
"Please, set your name with command like:\n"
920
'bzr whoami "Your Name <name@domain.com>"')
921
host = win32utils.get_host_name_unicode()
923
host = socket.gethostname()
924
return name, (name + '@' + host)
930
w = pwd.getpwuid(uid)
932
raise errors.BzrCommandError('Unable to determine your name. '
933
'Please use "bzr whoami" to set it.')
935
# we try utf-8 first, because on many variants (like Linux),
936
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
937
# false positives. (many users will have their user encoding set to
938
# latin-1, which cannot raise UnicodeError.)
940
gecos = w.pw_gecos.decode('utf-8')
944
encoding = osutils.get_user_encoding()
945
gecos = w.pw_gecos.decode(encoding)
947
raise errors.BzrCommandError('Unable to determine your name. '
948
'Use "bzr whoami" to set it.')
950
username = w.pw_name.decode(encoding)
952
raise errors.BzrCommandError('Unable to determine your name. '
953
'Use "bzr whoami" to set it.')
955
comma = gecos.find(',')
959
realname = gecos[:comma]
966
user_encoding = osutils.get_user_encoding()
967
realname = username = getpass.getuser().decode(user_encoding)
968
except UnicodeDecodeError:
969
raise errors.BzrError("Can't decode username as %s." % \
972
return realname, (username + '@' + socket.gethostname())
975
1216
def parse_username(username):
976
1217
"""Parse e-mail username and return a (name, address) tuple."""
977
1218
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1517
1781
return StringIO()
1519
1783
def _get_configobj(self):
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
1784
f = self._get_config_file()
1786
return ConfigObj(f, encoding='utf-8')
1522
1790
def _set_configobj(self, configobj):
1523
1791
out_file = StringIO()
1524
1792
configobj.write(out_file)
1525
1793
out_file.seek(0)
1526
1794
self._transport.put_file(self._filename, out_file)
1797
class cmd_config(commands.Command):
1798
__doc__ = """Display, set or remove a configuration option.
1800
Display the active value for a given option.
1802
If --all is specified, NAME is interpreted as a regular expression and all
1803
matching options are displayed mentioning their scope. The active value
1804
that bzr will take into account is the first one displayed for each option.
1806
If no NAME is given, --all .* is implied.
1808
Setting a value is achieved by using name=value without spaces. The value
1809
is set in the most relevant scope and can be checked by displaying the
1813
takes_args = ['name?']
1817
# FIXME: This should be a registry option so that plugins can register
1818
# their own config files (or not) -- vila 20101002
1819
commands.Option('scope', help='Reduce the scope to the specified'
1820
' configuration file',
1822
commands.Option('all',
1823
help='Display all the defined values for the matching options.',
1825
commands.Option('remove', help='Remove the option from'
1826
' the configuration file'),
1829
@commands.display_command
1830
def run(self, name=None, all=False, directory=None, scope=None,
1832
if directory is None:
1834
directory = urlutils.normalize_url(directory)
1836
raise errors.BzrError(
1837
'--all and --remove are mutually exclusive.')
1839
# Delete the option in the given scope
1840
self._remove_config_option(name, directory, scope)
1842
# Defaults to all options
1843
self._show_matching_options('.*', directory, scope)
1846
name, value = name.split('=', 1)
1848
# Display the option(s) value(s)
1850
self._show_matching_options(name, directory, scope)
1852
self._show_value(name, directory, scope)
1855
raise errors.BzrError(
1856
'Only one option can be set.')
1857
# Set the option value
1858
self._set_config_option(name, value, directory, scope)
1860
def _get_configs(self, directory, scope=None):
1861
"""Iterate the configurations specified by ``directory`` and ``scope``.
1863
:param directory: Where the configurations are derived from.
1865
:param scope: A specific config to start from.
1867
if scope is not None:
1868
if scope == 'bazaar':
1869
yield GlobalConfig()
1870
elif scope == 'locations':
1871
yield LocationConfig(directory)
1872
elif scope == 'branch':
1873
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1875
yield br.get_config()
1878
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1880
yield br.get_config()
1881
except errors.NotBranchError:
1882
yield LocationConfig(directory)
1883
yield GlobalConfig()
1885
def _show_value(self, name, directory, scope):
1887
for c in self._get_configs(directory, scope):
1890
for (oname, value, section, conf_id, parser) in c._get_options():
1892
# Display only the first value and exit
1894
# FIXME: We need to use get_user_option to take policies
1895
# into account and we need to make sure the option exists
1896
# too (hence the two for loops), this needs a better API
1898
value = c.get_user_option(name)
1899
# Quote the value appropriately
1900
value = parser._quote(value)
1901
self.outf.write('%s\n' % (value,))
1905
raise errors.NoSuchConfigOption(name)
1907
def _show_matching_options(self, name, directory, scope):
1908
name = re.compile(name)
1909
# We want any error in the regexp to be raised *now* so we need to
1910
# avoid the delay introduced by the lazy regexp.
1911
name._compile_and_collapse()
1914
for c in self._get_configs(directory, scope):
1915
for (oname, value, section, conf_id, parser) in c._get_options():
1916
if name.search(oname):
1917
if cur_conf_id != conf_id:
1918
# Explain where the options are defined
1919
self.outf.write('%s:\n' % (conf_id,))
1920
cur_conf_id = conf_id
1922
if (section not in (None, 'DEFAULT')
1923
and cur_section != section):
1924
# Display the section if it's not the default (or only)
1926
self.outf.write(' [%s]\n' % (section,))
1927
cur_section = section
1928
self.outf.write(' %s = %s\n' % (oname, value))
1930
def _set_config_option(self, name, value, directory, scope):
1931
for conf in self._get_configs(directory, scope):
1932
conf.set_user_option(name, value)
1935
raise errors.NoSuchConfig(scope)
1937
def _remove_config_option(self, name, directory, scope):
1939
raise errors.BzrCommandError(
1940
'--remove expects an option to remove.')
1942
for conf in self._get_configs(directory, scope):
1943
for (section_name, section, conf_id) in conf._get_sections():
1944
if scope is not None and conf_id != scope:
1945
# Not the right configuration file
1948
if conf_id != conf.config_id():
1949
conf = self._get_configs(directory, conf_id).next()
1950
# We use the first section in the first config where the
1951
# option is defined to remove it
1952
conf.remove_user_option(name, section_name)
1957
raise errors.NoSuchConfig(scope)
1959
raise errors.NoSuchConfigOption(name)
added
removed
bzrlib/config.py
