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] = value
367
trace.mutter('loaded merge tools: %r' % tools)
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))
350
380
class IniBasedConfig(Config):
351
381
"""A configuration policy that draws from ini files."""
353
def __init__(self, get_filename):
383
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
385
"""Base class for configuration files using an ini-like syntax.
387
:param file_name: The configuration file path.
354
389
super(IniBasedConfig, self).__init__()
355
self._get_filename = get_filename
390
self.file_name = file_name
391
if symbol_versioning.deprecated_passed(get_filename):
392
symbol_versioning.warn(
393
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
394
' Use file_name instead.',
397
if get_filename is not None:
398
self.file_name = get_filename()
400
self.file_name = file_name
356
402
self._parser = None
358
def _get_parser(self, file=None):
405
def from_string(cls, str_or_unicode, file_name=None, save=False):
406
"""Create a config object from a string.
408
:param str_or_unicode: A string representing the file content. This will
411
:param file_name: The configuration file path.
413
:param _save: Whether the file should be saved upon creation.
415
conf = cls(file_name=file_name)
416
conf._create_from_string(str_or_unicode, save)
419
def _create_from_string(self, str_or_unicode, save):
420
self._content = StringIO(str_or_unicode.encode('utf-8'))
421
# Some tests use in-memory configs, some other always need the config
422
# file to exist on disk.
424
self._write_config_file()
426
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
359
427
if self._parser is not None:
360
428
return self._parser
362
input = self._get_filename()
429
if symbol_versioning.deprecated_passed(file):
430
symbol_versioning.warn(
431
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
432
' Use IniBasedConfig(_content=xxx) instead.',
435
if self._content is not None:
436
co_input = self._content
437
elif self.file_name is None:
438
raise AssertionError('We have no content to create the config')
440
co_input = self.file_name
366
self._parser = ConfigObj(input, encoding='utf-8')
442
self._parser = ConfigObj(co_input, encoding='utf-8')
367
443
except configobj.ConfigObjError, e:
368
444
raise errors.ParseConfigError(e.errors, e.config.filename)
445
# Make sure self.reload() will use the right file name
446
self._parser.filename = self.file_name
369
447
return self._parser
450
"""Reload the config file from disk."""
451
if self.file_name is None:
452
raise AssertionError('We need a file name to reload the config')
453
if self._parser is not None:
454
self._parser.reload()
371
456
def _get_matching_sections(self):
372
457
"""Return an ordered list of (section_name, extra_path) pairs.
384
469
"""Override this to define the section used by the config."""
472
def _get_sections(self, name=None):
473
"""Returns an iterator of the sections specified by ``name``.
475
:param name: The section name. If None is supplied, the default
476
configurations are yielded.
478
:return: A tuple (name, section, config_id) for all sections that will
479
be walked by user_get_option() in the 'right' order. The first one
480
is where set_user_option() will update the value.
482
parser = self._get_parser()
484
yield (name, parser[name], self.config_id())
486
# No section name has been given so we fallback to the configobj
487
# itself which holds the variables defined outside of any section.
488
yield (None, parser, self.config_id())
490
def _get_options(self, sections=None):
491
"""Return an ordered list of (name, value, section, config_id) tuples.
493
All options are returned with their associated value and the section
494
they appeared in. ``config_id`` is a unique identifier for the
495
configuration file the option is defined in.
497
:param sections: Default to ``_get_matching_sections`` if not
498
specified. This gives a better control to daughter classes about
499
which sections should be searched. This is a list of (name,
504
parser = self._get_parser()
506
for (section_name, _) in self._get_matching_sections():
508
section = parser[section_name]
510
# This could happen for an empty file for which we define a
511
# DEFAULT section. FIXME: Force callers to provide sections
512
# instead ? -- vila 20100930
514
sections.append((section_name, section))
515
config_id = self.config_id()
516
for (section_name, section) in sections:
517
for (name, value) in section.iteritems():
518
yield (name, parser._quote(value), section_name,
387
521
def _get_option_policy(self, section, option_name):
388
522
"""Return the policy for the given (section, option_name) pair."""
389
523
return POLICY_NONE
476
610
def _get_nickname(self):
477
611
return self.get_user_option('nickname')
480
class GlobalConfig(IniBasedConfig):
613
def remove_user_option(self, option_name, section_name=None):
614
"""Remove a user option and save the configuration file.
616
:param option_name: The option to be removed.
618
:param section_name: The section the option is defined in, default to
622
parser = self._get_parser()
623
if section_name is None:
626
section = parser[section_name]
628
del section[option_name]
630
raise errors.NoSuchConfigOption(option_name)
631
self._write_config_file()
633
def _write_config_file(self):
634
if self.file_name is None:
635
raise AssertionError('We cannot save, self.file_name is None')
636
conf_dir = os.path.dirname(self.file_name)
637
ensure_config_dir_exists(conf_dir)
638
atomic_file = atomicfile.AtomicFile(self.file_name)
639
self._get_parser().write(atomic_file)
642
osutils.copy_ownership_from_path(self.file_name)
645
class LockableConfig(IniBasedConfig):
646
"""A configuration needing explicit locking for access.
648
If several processes try to write the config file, the accesses need to be
651
Daughter classes should decorate all methods that update a config with the
652
``@needs_write_lock`` decorator (they call, directly or indirectly, the
653
``_write_config_file()`` method. These methods (typically ``set_option()``
654
and variants must reload the config file from disk before calling
655
``_write_config_file()``), this can be achieved by calling the
656
``self.reload()`` method. Note that the lock scope should cover both the
657
reading and the writing of the config file which is why the decorator can't
658
be applied to ``_write_config_file()`` only.
660
This should be enough to implement the following logic:
661
- lock for exclusive write access,
662
- reload the config file from disk,
666
This logic guarantees that a writer can update a value without erasing an
667
update made by another writer.
672
def __init__(self, file_name):
673
super(LockableConfig, self).__init__(file_name=file_name)
674
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
675
self.transport = transport.get_transport(self.dir)
676
self._lock = lockdir.LockDir(self.transport, 'lock')
678
def _create_from_string(self, unicode_bytes, save):
679
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
681
# We need to handle the saving here (as opposed to IniBasedConfig)
684
self._write_config_file()
687
def lock_write(self, token=None):
688
"""Takes a write lock in the directory containing the config file.
690
If the directory doesn't exist it is created.
692
ensure_config_dir_exists(self.dir)
693
return self._lock.lock_write(token)
698
def break_lock(self):
699
self._lock.break_lock()
702
def remove_user_option(self, option_name, section_name=None):
703
super(LockableConfig, self).remove_user_option(option_name,
706
def _write_config_file(self):
707
if self._lock is None or not self._lock.is_held:
708
# NB: if the following exception is raised it probably means a
709
# missing @needs_write_lock decorator on one of the callers.
710
raise errors.ObjectNotLocked(self)
711
super(LockableConfig, self)._write_config_file()
714
class GlobalConfig(LockableConfig):
481
715
"""The configuration that should be used for a specific location."""
718
super(GlobalConfig, self).__init__(file_name=config_filename())
724
def from_string(cls, str_or_unicode, save=False):
725
"""Create a config object from a string.
727
:param str_or_unicode: A string representing the file content. This
728
will be utf-8 encoded.
730
:param save: Whether the file should be saved upon creation.
733
conf._create_from_string(str_or_unicode, save)
483
736
def get_editor(self):
484
737
return self._get_user_option('editor')
487
super(GlobalConfig, self).__init__(config_filename)
489
740
def set_user_option(self, option, value):
490
741
"""Save option and its value in the configuration."""
491
742
self._set_option(option, value, 'DEFAULT')
510
764
self._write_config_file()
512
766
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
768
self._get_parser().setdefault(section, {})[option] = value
518
769
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):
772
def _get_sections(self, name=None):
773
"""See IniBasedConfig._get_sections()."""
774
parser = self._get_parser()
775
# We don't give access to options defined outside of any section, we
776
# used the DEFAULT section by... default.
777
if name in (None, 'DEFAULT'):
778
# This could happen for an empty file where the DEFAULT section
779
# doesn't exist yet. So we force DEFAULT when yielding
781
if 'DEFAULT' not in parser:
782
parser['DEFAULT']= {}
783
yield (name, parser[name], self.config_id())
786
def remove_user_option(self, option_name, section_name=None):
787
if section_name is None:
788
# We need to force the default section.
789
section_name = 'DEFAULT'
790
# We need to avoid the LockableConfig implementation or we'll lock
792
super(LockableConfig, self).remove_user_option(option_name,
796
class LocationConfig(LockableConfig):
529
797
"""A configuration object that gives the policy for a location."""
531
799
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)
800
super(LocationConfig, self).__init__(
801
file_name=locations_config_filename())
544
802
# local file locations are looked up by local path, rather than
545
803
# by file url. This is because the config file is a user
546
804
# file, and we would rather not expose the user to file urls.
648
934
STORE_LOCATION_APPENDPATH]:
649
935
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
938
location = self.location
656
939
if location.endswith('/'):
657
940
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():
941
parser = self._get_parser()
942
if not location in parser and not location + '/' in parser:
943
parser[location] = {}
944
elif location + '/' in parser:
662
945
location = location + '/'
663
self._get_parser()[location][option]=value
946
parser[location][option]=value
664
947
# the allowed values of store match the config policies
665
948
self._set_option_policy(location, option, store)
666
self._get_parser().write(file(self._get_filename(), 'wb'))
949
self._write_config_file()
669
952
class BranchConfig(Config):
670
953
"""A configuration object giving the policy for a branch."""
955
def __init__(self, branch):
956
super(BranchConfig, self).__init__()
957
self._location_config = None
958
self._branch_data_config = None
959
self._global_config = None
961
self.option_sources = (self._get_location_config,
962
self._get_branch_data_config,
963
self._get_global_config)
672
968
def _get_branch_data_config(self):
673
969
if self._branch_data_config is None:
674
970
self._branch_data_config = TreeConfig(self.branch)
971
self._branch_data_config.config_id = self.config_id
675
972
return self._branch_data_config
677
974
def _get_location_config(self):
1045
def _get_sections(self, name=None):
1046
"""See IniBasedConfig.get_sections()."""
1047
for source in self.option_sources:
1048
for section in source()._get_sections(name):
1051
def _get_options(self, sections=None):
1053
# First the locations options
1054
for option in self._get_location_config()._get_options():
1056
# Then the branch options
1057
branch_config = self._get_branch_data_config()
1058
if sections is None:
1059
sections = [('DEFAULT', branch_config._get_parser())]
1060
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1061
# Config itself has no notion of sections :( -- vila 20101001
1062
config_id = self.config_id()
1063
for (section_name, section) in sections:
1064
for (name, value) in section.iteritems():
1065
yield (name, value, section_name,
1066
config_id, branch_config._get_parser())
1067
# Then the global options
1068
for option in self._get_global_config()._get_options():
748
1071
def set_user_option(self, name, value, store=STORE_BRANCH,
749
1072
warn_masked=False):
750
1073
if store == STORE_BRANCH:
826
1142
def config_dir():
827
1143
"""Return per-user configuration directory.
829
By default this is ~/.bazaar/
1145
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1146
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1147
that will be used instead.
831
1149
TODO: Global option --config-dir to override this.
833
1151
base = os.environ.get('BZR_HOME', None)
834
1152
if sys.platform == 'win32':
1153
# environ variables on Windows are in user encoding/mbcs. So decode
1155
if base is not None:
1156
base = base.decode('mbcs')
835
1157
if base is None:
836
1158
base = win32utils.get_appdata_location_unicode()
837
1159
if base is None:
838
1160
base = os.environ.get('HOME', None)
1161
if base is not None:
1162
base = base.decode('mbcs')
839
1163
if base is None:
840
1164
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
842
1166
return osutils.pathjoin(base, 'bazaar', '2.0')
1167
elif sys.platform == 'darwin':
1169
# this takes into account $HOME
1170
base = os.path.expanduser("~")
1171
return osutils.pathjoin(base, '.bazaar')
844
# cygwin, linux, and darwin all have a $HOME directory
845
1173
if base is None:
1175
xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1177
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1178
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1179
if osutils.isdir(xdg_dir):
1181
"Using configuration in XDG directory %s." % xdg_dir)
846
1184
base = os.path.expanduser("~")
847
1185
return osutils.pathjoin(base, ".bazaar")
899
1232
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
1235
def parse_username(username):
976
1236
"""Parse e-mail username and return a (name, address) tuple."""
977
1237
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1517
1800
return StringIO()
1519
1802
def _get_configobj(self):
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
1803
f = self._get_config_file()
1805
return ConfigObj(f, encoding='utf-8')
1522
1809
def _set_configobj(self, configobj):
1523
1810
out_file = StringIO()
1524
1811
configobj.write(out_file)
1525
1812
out_file.seek(0)
1526
1813
self._transport.put_file(self._filename, out_file)
1816
class cmd_config(commands.Command):
1817
__doc__ = """Display, set or remove a configuration option.
1819
Display the active value for a given option.
1821
If --all is specified, NAME is interpreted as a regular expression and all
1822
matching options are displayed mentioning their scope. The active value
1823
that bzr will take into account is the first one displayed for each option.
1825
If no NAME is given, --all .* is implied.
1827
Setting a value is achieved by using name=value without spaces. The value
1828
is set in the most relevant scope and can be checked by displaying the
1832
takes_args = ['name?']
1836
# FIXME: This should be a registry option so that plugins can register
1837
# their own config files (or not) -- vila 20101002
1838
commands.Option('scope', help='Reduce the scope to the specified'
1839
' configuration file',
1841
commands.Option('all',
1842
help='Display all the defined values for the matching options.',
1844
commands.Option('remove', help='Remove the option from'
1845
' the configuration file'),
1848
@commands.display_command
1849
def run(self, name=None, all=False, directory=None, scope=None,
1851
if directory is None:
1853
directory = urlutils.normalize_url(directory)
1855
raise errors.BzrError(
1856
'--all and --remove are mutually exclusive.')
1858
# Delete the option in the given scope
1859
self._remove_config_option(name, directory, scope)
1861
# Defaults to all options
1862
self._show_matching_options('.*', directory, scope)
1865
name, value = name.split('=', 1)
1867
# Display the option(s) value(s)
1869
self._show_matching_options(name, directory, scope)
1871
self._show_value(name, directory, scope)
1874
raise errors.BzrError(
1875
'Only one option can be set.')
1876
# Set the option value
1877
self._set_config_option(name, value, directory, scope)
1879
def _get_configs(self, directory, scope=None):
1880
"""Iterate the configurations specified by ``directory`` and ``scope``.
1882
:param directory: Where the configurations are derived from.
1884
:param scope: A specific config to start from.
1886
if scope is not None:
1887
if scope == 'bazaar':
1888
yield GlobalConfig()
1889
elif scope == 'locations':
1890
yield LocationConfig(directory)
1891
elif scope == 'branch':
1892
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1894
yield br.get_config()
1897
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1899
yield br.get_config()
1900
except errors.NotBranchError:
1901
yield LocationConfig(directory)
1902
yield GlobalConfig()
1904
def _show_value(self, name, directory, scope):
1906
for c in self._get_configs(directory, scope):
1909
for (oname, value, section, conf_id, parser) in c._get_options():
1911
# Display only the first value and exit
1913
# FIXME: We need to use get_user_option to take policies
1914
# into account and we need to make sure the option exists
1915
# too (hence the two for loops), this needs a better API
1917
value = c.get_user_option(name)
1918
# Quote the value appropriately
1919
value = parser._quote(value)
1920
self.outf.write('%s\n' % (value,))
1924
raise errors.NoSuchConfigOption(name)
1926
def _show_matching_options(self, name, directory, scope):
1927
name = re.compile(name)
1928
# We want any error in the regexp to be raised *now* so we need to
1929
# avoid the delay introduced by the lazy regexp.
1930
name._compile_and_collapse()
1933
for c in self._get_configs(directory, scope):
1934
for (oname, value, section, conf_id, parser) in c._get_options():
1935
if name.search(oname):
1936
if cur_conf_id != conf_id:
1937
# Explain where the options are defined
1938
self.outf.write('%s:\n' % (conf_id,))
1939
cur_conf_id = conf_id
1941
if (section not in (None, 'DEFAULT')
1942
and cur_section != section):
1943
# Display the section if it's not the default (or only)
1945
self.outf.write(' [%s]\n' % (section,))
1946
cur_section = section
1947
self.outf.write(' %s = %s\n' % (oname, value))
1949
def _set_config_option(self, name, value, directory, scope):
1950
for conf in self._get_configs(directory, scope):
1951
conf.set_user_option(name, value)
1954
raise errors.NoSuchConfig(scope)
1956
def _remove_config_option(self, name, directory, scope):
1958
raise errors.BzrCommandError(
1959
'--remove expects an option to remove.')
1961
for conf in self._get_configs(directory, scope):
1962
for (section_name, section, conf_id) in conf._get_sections():
1963
if scope is not None and conf_id != scope:
1964
# Not the right configuration file
1967
if conf_id != conf.config_id():
1968
conf = self._get_configs(directory, conf_id).next()
1969
# We use the first section in the first config where the
1970
# option is defined to remove it
1971
conf.remove_user_option(name, section_name)
1976
raise errors.NoSuchConfig(scope)
1978
raise errors.NoSuchConfigOption(name)
added
removed
bzrlib/config.py
