361
350
class IniBasedConfig(Config):
362
351
"""A configuration policy that draws from ini files."""
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.
353
def __init__(self, get_filename):
370
354
super(IniBasedConfig, self).__init__()
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
355
self._get_filename = get_filename
383
356
self._parser = 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):
358
def _get_parser(self, file=None):
408
359
if self._parser is not None:
409
360
return self._parser
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')
362
input = self._get_filename()
421
co_input = self.file_name
423
self._parser = ConfigObj(co_input, encoding='utf-8')
366
self._parser = ConfigObj(input, encoding='utf-8')
424
367
except configobj.ConfigObjError, e:
425
368
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
428
369
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()
437
371
def _get_matching_sections(self):
438
372
"""Return an ordered list of (section_name, extra_path) pairs.
450
384
"""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,
502
387
def _get_option_policy(self, section, option_name):
503
388
"""Return the policy for the given (section, option_name) pair."""
504
389
return POLICY_NONE
591
476
def _get_nickname(self):
592
477
return self.get_user_option('nickname')
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):
480
class GlobalConfig(IniBasedConfig):
696
481
"""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)
717
483
def get_editor(self):
718
484
return self._get_user_option('editor')
487
super(GlobalConfig, self).__init__(config_filename)
721
489
def set_user_option(self, option, value):
722
490
"""Save option and its value in the configuration."""
723
491
self._set_option(option, value, 'DEFAULT')
745
510
self._write_config_file()
747
512
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)
749
517
self._get_parser().setdefault(section, {})[option] = value
750
518
self._write_config_file()
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):
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):
778
529
"""A configuration object that gives the policy for a location."""
780
531
def __init__(self, location):
781
super(LocationConfig, self).__init__(
782
file_name=locations_config_filename())
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)
783
544
# local file locations are looked up by local path, rather than
784
545
# by file url. This is because the config file is a user
785
546
# file, and we would rather not expose the user to file urls.
915
648
STORE_LOCATION_APPENDPATH]:
916
649
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)
919
655
location = self.location
920
656
if location.endswith('/'):
921
657
location = location[:-1]
922
parser = self._get_parser()
923
if not location in parser and not location + '/' in parser:
924
parser[location] = {}
925
elif location + '/' in parser:
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():
926
662
location = location + '/'
927
parser[location][option]=value
663
self._get_parser()[location][option]=value
928
664
# the allowed values of store match the config policies
929
665
self._set_option_policy(location, option, store)
930
self._write_config_file()
666
self._get_parser().write(file(self._get_filename(), 'wb'))
933
669
class BranchConfig(Config):
934
670
"""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)
949
672
def _get_branch_data_config(self):
950
673
if self._branch_data_config is None:
951
674
self._branch_data_config = TreeConfig(self.branch)
952
self._branch_data_config.config_id = self.config_id
953
675
return self._branch_data_config
955
677
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():
1052
748
def set_user_option(self, name, value, store=STORE_BRANCH,
1053
749
warn_masked=False):
1054
750
if store == STORE_BRANCH:
1123
826
def config_dir():
1124
827
"""Return per-user configuration directory.
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.
829
By default this is ~/.bazaar/
1130
831
TODO: Global option --config-dir to override this.
1132
833
base = os.environ.get('BZR_HOME', None)
1133
834
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')
1138
835
if base is None:
1139
836
base = win32utils.get_appdata_location_unicode()
1140
837
if base is None:
1141
838
base = os.environ.get('HOME', None)
1142
if base is not None:
1143
base = base.decode('mbcs')
1144
839
if base is None:
1145
840
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
1147
842
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
1154
845
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)
1165
846
base = os.path.expanduser("~")
1166
847
return osutils.pathjoin(base, ".bazaar")
1213
899
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())
1216
975
def parse_username(username):
1217
976
"""Parse e-mail username and return a (name, address) tuple."""
1218
977
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1781
1517
return StringIO()
1783
1519
def _get_configobj(self):
1784
f = self._get_config_file()
1786
return ConfigObj(f, encoding='utf-8')
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
1790
1522
def _set_configobj(self, configobj):
1791
1523
out_file = StringIO()
1792
1524
configobj.write(out_file)
1793
1525
out_file.seek(0)
1794
1526
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
