361
def get_merge_tools(self):
363
for (oname, value, section, conf_id, parser) in self._get_options():
364
if oname.startswith('bzr.mergetool.'):
365
tool_name = oname[len('bzr.mergetool.'):]
366
tools[tool_name] = mergetools.MergeTool(tool_name, value)
367
trace.mutter('loaded merge tools: %r' % tools)
368
return tools.values()
370
def find_merge_tool(self, name):
371
# We fake a defaults mechanism here by checking if the given name can
372
# be found in the known_merge_tools if it's not found in the config.
373
# This should be done through the proposed config defaults mechanism
374
# when it becomes available in the future.
375
command_line = (self.get_user_option('bzr.mergetool.%s' % name) or
376
mergetools.known_merge_tools.get(name, None))
377
if command_line is None:
379
return mergetools.MergeTool(name, command_line)
381
def get_default_merge_tool(self):
382
return self.get_user_option('bzr.default_mergetool')
350
385
class IniBasedConfig(Config):
351
386
"""A configuration policy that draws from ini files."""
353
def __init__(self, get_filename):
388
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
390
"""Base class for configuration files using an ini-like syntax.
392
:param file_name: The configuration file path.
354
394
super(IniBasedConfig, self).__init__()
355
self._get_filename = get_filename
395
self.file_name = file_name
396
if symbol_versioning.deprecated_passed(get_filename):
397
symbol_versioning.warn(
398
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
399
' Use file_name instead.',
402
if get_filename is not None:
403
self.file_name = get_filename()
405
self.file_name = file_name
356
407
self._parser = None
358
def _get_parser(self, file=None):
410
def from_string(cls, str_or_unicode, file_name=None, save=False):
411
"""Create a config object from a string.
413
:param str_or_unicode: A string representing the file content. This will
416
:param file_name: The configuration file path.
418
:param _save: Whether the file should be saved upon creation.
420
conf = cls(file_name=file_name)
421
conf._create_from_string(str_or_unicode, save)
424
def _create_from_string(self, str_or_unicode, save):
425
self._content = StringIO(str_or_unicode.encode('utf-8'))
426
# Some tests use in-memory configs, some other always need the config
427
# file to exist on disk.
429
self._write_config_file()
431
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
359
432
if self._parser is not None:
360
433
return self._parser
362
input = self._get_filename()
434
if symbol_versioning.deprecated_passed(file):
435
symbol_versioning.warn(
436
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
437
' Use IniBasedConfig(_content=xxx) instead.',
440
if self._content is not None:
441
co_input = self._content
442
elif self.file_name is None:
443
raise AssertionError('We have no content to create the config')
445
co_input = self.file_name
366
self._parser = ConfigObj(input, encoding='utf-8')
447
self._parser = ConfigObj(co_input, encoding='utf-8')
367
448
except configobj.ConfigObjError, e:
368
449
raise errors.ParseConfigError(e.errors, e.config.filename)
450
# Make sure self.reload() will use the right file name
451
self._parser.filename = self.file_name
369
452
return self._parser
455
"""Reload the config file from disk."""
456
if self.file_name is None:
457
raise AssertionError('We need a file name to reload the config')
458
if self._parser is not None:
459
self._parser.reload()
371
461
def _get_matching_sections(self):
372
462
"""Return an ordered list of (section_name, extra_path) pairs.
384
474
"""Override this to define the section used by the config."""
477
def _get_sections(self, name=None):
478
"""Returns an iterator of the sections specified by ``name``.
480
:param name: The section name. If None is supplied, the default
481
configurations are yielded.
483
:return: A tuple (name, section, config_id) for all sections that will
484
be walked by user_get_option() in the 'right' order. The first one
485
is where set_user_option() will update the value.
487
parser = self._get_parser()
489
yield (name, parser[name], self.config_id())
491
# No section name has been given so we fallback to the configobj
492
# itself which holds the variables defined outside of any section.
493
yield (None, parser, self.config_id())
495
def _get_options(self, sections=None):
496
"""Return an ordered list of (name, value, section, config_id) tuples.
498
All options are returned with their associated value and the section
499
they appeared in. ``config_id`` is a unique identifier for the
500
configuration file the option is defined in.
502
:param sections: Default to ``_get_matching_sections`` if not
503
specified. This gives a better control to daughter classes about
504
which sections should be searched. This is a list of (name,
509
parser = self._get_parser()
511
for (section_name, _) in self._get_matching_sections():
513
section = parser[section_name]
515
# This could happen for an empty file for which we define a
516
# DEFAULT section. FIXME: Force callers to provide sections
517
# instead ? -- vila 20100930
519
sections.append((section_name, section))
520
config_id = self.config_id()
521
for (section_name, section) in sections:
522
for (name, value) in section.iteritems():
523
yield (name, parser._quote(value), section_name,
387
526
def _get_option_policy(self, section, option_name):
388
527
"""Return the policy for the given (section, option_name) pair."""
389
528
return POLICY_NONE
476
615
def _get_nickname(self):
477
616
return self.get_user_option('nickname')
480
class GlobalConfig(IniBasedConfig):
618
def remove_user_option(self, option_name, section_name=None):
619
"""Remove a user option and save the configuration file.
621
:param option_name: The option to be removed.
623
:param section_name: The section the option is defined in, default to
627
parser = self._get_parser()
628
if section_name is None:
631
section = parser[section_name]
633
del section[option_name]
635
raise errors.NoSuchConfigOption(option_name)
636
self._write_config_file()
638
def _write_config_file(self):
639
if self.file_name is None:
640
raise AssertionError('We cannot save, self.file_name is None')
641
conf_dir = os.path.dirname(self.file_name)
642
ensure_config_dir_exists(conf_dir)
643
atomic_file = atomicfile.AtomicFile(self.file_name)
644
self._get_parser().write(atomic_file)
647
osutils.copy_ownership_from_path(self.file_name)
650
class LockableConfig(IniBasedConfig):
651
"""A configuration needing explicit locking for access.
653
If several processes try to write the config file, the accesses need to be
656
Daughter classes should decorate all methods that update a config with the
657
``@needs_write_lock`` decorator (they call, directly or indirectly, the
658
``_write_config_file()`` method. These methods (typically ``set_option()``
659
and variants must reload the config file from disk before calling
660
``_write_config_file()``), this can be achieved by calling the
661
``self.reload()`` method. Note that the lock scope should cover both the
662
reading and the writing of the config file which is why the decorator can't
663
be applied to ``_write_config_file()`` only.
665
This should be enough to implement the following logic:
666
- lock for exclusive write access,
667
- reload the config file from disk,
671
This logic guarantees that a writer can update a value without erasing an
672
update made by another writer.
677
def __init__(self, file_name):
678
super(LockableConfig, self).__init__(file_name=file_name)
679
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
680
self.transport = transport.get_transport(self.dir)
681
self._lock = lockdir.LockDir(self.transport, 'lock')
683
def _create_from_string(self, unicode_bytes, save):
684
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
686
# We need to handle the saving here (as opposed to IniBasedConfig)
689
self._write_config_file()
692
def lock_write(self, token=None):
693
"""Takes a write lock in the directory containing the config file.
695
If the directory doesn't exist it is created.
697
ensure_config_dir_exists(self.dir)
698
return self._lock.lock_write(token)
703
def break_lock(self):
704
self._lock.break_lock()
707
def remove_user_option(self, option_name, section_name=None):
708
super(LockableConfig, self).remove_user_option(option_name,
711
def _write_config_file(self):
712
if self._lock is None or not self._lock.is_held:
713
# NB: if the following exception is raised it probably means a
714
# missing @needs_write_lock decorator on one of the callers.
715
raise errors.ObjectNotLocked(self)
716
super(LockableConfig, self)._write_config_file()
719
class GlobalConfig(LockableConfig):
481
720
"""The configuration that should be used for a specific location."""
723
super(GlobalConfig, self).__init__(file_name=config_filename())
729
def from_string(cls, str_or_unicode, save=False):
730
"""Create a config object from a string.
732
:param str_or_unicode: A string representing the file content. This
733
will be utf-8 encoded.
735
:param save: Whether the file should be saved upon creation.
738
conf._create_from_string(str_or_unicode, save)
483
741
def get_editor(self):
484
742
return self._get_user_option('editor')
487
super(GlobalConfig, self).__init__(config_filename)
489
745
def set_user_option(self, option, value):
490
746
"""Save option and its value in the configuration."""
491
747
self._set_option(option, value, 'DEFAULT')
510
769
self._write_config_file()
512
771
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
773
self._get_parser().setdefault(section, {})[option] = value
518
774
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):
777
def _get_sections(self, name=None):
778
"""See IniBasedConfig._get_sections()."""
779
parser = self._get_parser()
780
# We don't give access to options defined outside of any section, we
781
# used the DEFAULT section by... default.
782
if name in (None, 'DEFAULT'):
783
# This could happen for an empty file where the DEFAULT section
784
# doesn't exist yet. So we force DEFAULT when yielding
786
if 'DEFAULT' not in parser:
787
parser['DEFAULT']= {}
788
yield (name, parser[name], self.config_id())
791
def remove_user_option(self, option_name, section_name=None):
792
if section_name is None:
793
# We need to force the default section.
794
section_name = 'DEFAULT'
795
# We need to avoid the LockableConfig implementation or we'll lock
797
super(LockableConfig, self).remove_user_option(option_name,
801
class LocationConfig(LockableConfig):
529
802
"""A configuration object that gives the policy for a location."""
531
804
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)
805
super(LocationConfig, self).__init__(
806
file_name=locations_config_filename())
544
807
# local file locations are looked up by local path, rather than
545
808
# by file url. This is because the config file is a user
546
809
# file, and we would rather not expose the user to file urls.
648
939
STORE_LOCATION_APPENDPATH]:
649
940
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
943
location = self.location
656
944
if location.endswith('/'):
657
945
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():
946
parser = self._get_parser()
947
if not location in parser and not location + '/' in parser:
948
parser[location] = {}
949
elif location + '/' in parser:
662
950
location = location + '/'
663
self._get_parser()[location][option]=value
951
parser[location][option]=value
664
952
# the allowed values of store match the config policies
665
953
self._set_option_policy(location, option, store)
666
self._get_parser().write(file(self._get_filename(), 'wb'))
954
self._write_config_file()
669
957
class BranchConfig(Config):
670
958
"""A configuration object giving the policy for a branch."""
960
def __init__(self, branch):
961
super(BranchConfig, self).__init__()
962
self._location_config = None
963
self._branch_data_config = None
964
self._global_config = None
966
self.option_sources = (self._get_location_config,
967
self._get_branch_data_config,
968
self._get_global_config)
672
973
def _get_branch_data_config(self):
673
974
if self._branch_data_config is None:
674
975
self._branch_data_config = TreeConfig(self.branch)
976
self._branch_data_config.config_id = self.config_id
675
977
return self._branch_data_config
677
979
def _get_location_config(self):
1050
def _get_sections(self, name=None):
1051
"""See IniBasedConfig.get_sections()."""
1052
for source in self.option_sources:
1053
for section in source()._get_sections(name):
1056
def _get_options(self, sections=None):
1058
# First the locations options
1059
for option in self._get_location_config()._get_options():
1061
# Then the branch options
1062
branch_config = self._get_branch_data_config()
1063
if sections is None:
1064
sections = [('DEFAULT', branch_config._get_parser())]
1065
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1066
# Config itself has no notion of sections :( -- vila 20101001
1067
config_id = self.config_id()
1068
for (section_name, section) in sections:
1069
for (name, value) in section.iteritems():
1070
yield (name, value, section_name,
1071
config_id, branch_config._get_parser())
1072
# Then the global options
1073
for option in self._get_global_config()._get_options():
748
1076
def set_user_option(self, name, value, store=STORE_BRANCH,
749
1077
warn_masked=False):
750
1078
if store == STORE_BRANCH:
826
1147
def config_dir():
827
1148
"""Return per-user configuration directory.
829
By default this is ~/.bazaar/
1150
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1151
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1152
that will be used instead.
831
1154
TODO: Global option --config-dir to override this.
833
1156
base = os.environ.get('BZR_HOME', None)
834
1157
if sys.platform == 'win32':
1158
# environ variables on Windows are in user encoding/mbcs. So decode
1160
if base is not None:
1161
base = base.decode('mbcs')
835
1162
if base is None:
836
1163
base = win32utils.get_appdata_location_unicode()
837
1164
if base is None:
838
1165
base = os.environ.get('HOME', None)
1166
if base is not None:
1167
base = base.decode('mbcs')
839
1168
if base is None:
840
1169
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
842
1171
return osutils.pathjoin(base, 'bazaar', '2.0')
1172
elif sys.platform == 'darwin':
1174
# this takes into account $HOME
1175
base = os.path.expanduser("~")
1176
return osutils.pathjoin(base, '.bazaar')
844
# cygwin, linux, and darwin all have a $HOME directory
845
1178
if base is None:
1180
xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1182
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1183
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1184
if osutils.isdir(xdg_dir):
1186
"Using configuration in XDG directory %s." % xdg_dir)
846
1189
base = os.path.expanduser("~")
847
1190
return osutils.pathjoin(base, ".bazaar")
899
1237
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
1240
def parse_username(username):
976
1241
"""Parse e-mail username and return a (name, address) tuple."""
977
1242
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1517
1805
return StringIO()
1519
1807
def _get_configobj(self):
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
1808
f = self._get_config_file()
1810
return ConfigObj(f, encoding='utf-8')
1522
1814
def _set_configobj(self, configobj):
1523
1815
out_file = StringIO()
1524
1816
configobj.write(out_file)
1525
1817
out_file.seek(0)
1526
1818
self._transport.put_file(self._filename, out_file)
1821
class cmd_config(commands.Command):
1822
__doc__ = """Display, set or remove a configuration option.
1824
Display the active value for a given option.
1826
If --all is specified, NAME is interpreted as a regular expression and all
1827
matching options are displayed mentioning their scope. The active value
1828
that bzr will take into account is the first one displayed for each option.
1830
If no NAME is given, --all .* is implied.
1832
Setting a value is achieved by using name=value without spaces. The value
1833
is set in the most relevant scope and can be checked by displaying the
1837
takes_args = ['name?']
1841
# FIXME: This should be a registry option so that plugins can register
1842
# their own config files (or not) -- vila 20101002
1843
commands.Option('scope', help='Reduce the scope to the specified'
1844
' configuration file',
1846
commands.Option('all',
1847
help='Display all the defined values for the matching options.',
1849
commands.Option('remove', help='Remove the option from'
1850
' the configuration file'),
1853
@commands.display_command
1854
def run(self, name=None, all=False, directory=None, scope=None,
1856
if directory is None:
1858
directory = urlutils.normalize_url(directory)
1860
raise errors.BzrError(
1861
'--all and --remove are mutually exclusive.')
1863
# Delete the option in the given scope
1864
self._remove_config_option(name, directory, scope)
1866
# Defaults to all options
1867
self._show_matching_options('.*', directory, scope)
1870
name, value = name.split('=', 1)
1872
# Display the option(s) value(s)
1874
self._show_matching_options(name, directory, scope)
1876
self._show_value(name, directory, scope)
1879
raise errors.BzrError(
1880
'Only one option can be set.')
1881
# Set the option value
1882
self._set_config_option(name, value, directory, scope)
1884
def _get_configs(self, directory, scope=None):
1885
"""Iterate the configurations specified by ``directory`` and ``scope``.
1887
:param directory: Where the configurations are derived from.
1889
:param scope: A specific config to start from.
1891
if scope is not None:
1892
if scope == 'bazaar':
1893
yield GlobalConfig()
1894
elif scope == 'locations':
1895
yield LocationConfig(directory)
1896
elif scope == 'branch':
1897
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1899
yield br.get_config()
1902
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1904
yield br.get_config()
1905
except errors.NotBranchError:
1906
yield LocationConfig(directory)
1907
yield GlobalConfig()
1909
def _show_value(self, name, directory, scope):
1911
for c in self._get_configs(directory, scope):
1914
for (oname, value, section, conf_id, parser) in c._get_options():
1916
# Display only the first value and exit
1918
# FIXME: We need to use get_user_option to take policies
1919
# into account and we need to make sure the option exists
1920
# too (hence the two for loops), this needs a better API
1922
value = c.get_user_option(name)
1923
# Quote the value appropriately
1924
value = parser._quote(value)
1925
self.outf.write('%s\n' % (value,))
1929
raise errors.NoSuchConfigOption(name)
1931
def _show_matching_options(self, name, directory, scope):
1932
name = re.compile(name)
1933
# We want any error in the regexp to be raised *now* so we need to
1934
# avoid the delay introduced by the lazy regexp.
1935
name._compile_and_collapse()
1938
for c in self._get_configs(directory, scope):
1939
for (oname, value, section, conf_id, parser) in c._get_options():
1940
if name.search(oname):
1941
if cur_conf_id != conf_id:
1942
# Explain where the options are defined
1943
self.outf.write('%s:\n' % (conf_id,))
1944
cur_conf_id = conf_id
1946
if (section not in (None, 'DEFAULT')
1947
and cur_section != section):
1948
# Display the section if it's not the default (or only)
1950
self.outf.write(' [%s]\n' % (section,))
1951
cur_section = section
1952
self.outf.write(' %s = %s\n' % (oname, value))
1954
def _set_config_option(self, name, value, directory, scope):
1955
for conf in self._get_configs(directory, scope):
1956
conf.set_user_option(name, value)
1959
raise errors.NoSuchConfig(scope)
1961
def _remove_config_option(self, name, directory, scope):
1963
raise errors.BzrCommandError(
1964
'--remove expects an option to remove.')
1966
for conf in self._get_configs(directory, scope):
1967
for (section_name, section, conf_id) in conf._get_sections():
1968
if scope is not None and conf_id != scope:
1969
# Not the right configuration file
1972
if conf_id != conf.config_id():
1973
conf = self._get_configs(directory, conf_id).next()
1974
# We use the first section in the first config where the
1975
# option is defined to remove it
1976
conf.remove_user_option(name, section_name)
1981
raise errors.NoSuchConfig(scope)
1983
raise errors.NoSuchConfigOption(name)
added
removed
bzrlib/config.py
