342
361
class IniBasedConfig(Config):
343
362
"""A configuration policy that draws from ini files."""
345
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.
346
370
super(IniBasedConfig, self).__init__()
347
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
348
383
self._parser = None
350
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):
351
408
if self._parser is not None:
352
409
return self._parser
354
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
358
self._parser = ConfigObj(input, encoding='utf-8')
423
self._parser = ConfigObj(co_input, encoding='utf-8')
359
424
except configobj.ConfigObjError, e:
360
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
361
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()
363
437
def _get_matching_sections(self):
364
438
"""Return an ordered list of (section_name, extra_path) pairs.
376
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,
379
502
def _get_option_policy(self, section, option_name):
380
503
"""Return the policy for the given (section, option_name) pair."""
381
504
return POLICY_NONE
468
591
def _get_nickname(self):
469
592
return self.get_user_option('nickname')
472
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):
473
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)
475
717
def get_editor(self):
476
718
return self._get_user_option('editor')
479
super(GlobalConfig, self).__init__(config_filename)
481
721
def set_user_option(self, option, value):
482
722
"""Save option and its value in the configuration."""
483
723
self._set_option(option, value, 'DEFAULT')
502
745
self._write_config_file()
504
747
def _set_option(self, option, value, section):
505
# FIXME: RBC 20051029 This should refresh the parser and also take a
506
# file lock on bazaar.conf.
507
conf_dir = os.path.dirname(self._get_filename())
508
ensure_config_dir_exists(conf_dir)
509
749
self._get_parser().setdefault(section, {})[option] = value
510
750
self._write_config_file()
512
def _write_config_file(self):
513
path = self._get_filename()
514
f = osutils.open_with_ownership(path, 'wb')
515
self._get_parser().write(f)
519
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):
520
778
"""A configuration object that gives the policy for a location."""
522
780
def __init__(self, location):
523
name_generator = locations_config_filename
524
if (not os.path.exists(name_generator()) and
525
os.path.exists(branches_config_filename())):
526
if sys.platform == 'win32':
527
trace.warning('Please rename %s to %s'
528
% (branches_config_filename(),
529
locations_config_filename()))
531
trace.warning('Please rename ~/.bazaar/branches.conf'
532
' to ~/.bazaar/locations.conf')
533
name_generator = branches_config_filename
534
super(LocationConfig, self).__init__(name_generator)
781
super(LocationConfig, self).__init__(
782
file_name=locations_config_filename())
535
783
# local file locations are looked up by local path, rather than
536
784
# by file url. This is because the config file is a user
537
785
# file, and we would rather not expose the user to file urls.
639
915
STORE_LOCATION_APPENDPATH]:
640
916
raise ValueError('bad storage policy %r for %r' %
642
# FIXME: RBC 20051029 This should refresh the parser and also take a
643
# file lock on locations.conf.
644
conf_dir = os.path.dirname(self._get_filename())
645
ensure_config_dir_exists(conf_dir)
646
919
location = self.location
647
920
if location.endswith('/'):
648
921
location = location[:-1]
649
if (not location in self._get_parser() and
650
not location + '/' in self._get_parser()):
651
self._get_parser()[location]={}
652
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:
653
926
location = location + '/'
654
self._get_parser()[location][option]=value
927
parser[location][option]=value
655
928
# the allowed values of store match the config policies
656
929
self._set_option_policy(location, option, store)
657
self._get_parser().write(file(self._get_filename(), 'wb'))
930
self._write_config_file()
660
933
class BranchConfig(Config):
661
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)
663
949
def _get_branch_data_config(self):
664
950
if self._branch_data_config is None:
665
951
self._branch_data_config = TreeConfig(self.branch)
952
self._branch_data_config.config_id = self.config_id
666
953
return self._branch_data_config
668
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():
739
1052
def set_user_option(self, name, value, store=STORE_BRANCH,
740
1053
warn_masked=False):
741
1054
if store == STORE_BRANCH:
889
1207
return os.path.expanduser('~/.cache')
893
"""Calculate automatic user identification.
895
Returns (realname, email).
897
Only used when none is set in the environment or the id file.
899
This previously used the FQDN as the default domain, but that can
900
be very slow on machines where DNS is broken. So now we simply
905
if sys.platform == 'win32':
906
name = win32utils.get_user_name_unicode()
908
raise errors.BzrError("Cannot autodetect user name.\n"
909
"Please, set your name with command like:\n"
910
'bzr whoami "Your Name <name@domain.com>"')
911
host = win32utils.get_host_name_unicode()
913
host = socket.gethostname()
914
return name, (name + '@' + host)
920
w = pwd.getpwuid(uid)
922
raise errors.BzrCommandError('Unable to determine your name. '
923
'Please use "bzr whoami" to set it.')
925
# we try utf-8 first, because on many variants (like Linux),
926
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
927
# false positives. (many users will have their user encoding set to
928
# latin-1, which cannot raise UnicodeError.)
930
gecos = w.pw_gecos.decode('utf-8')
934
encoding = osutils.get_user_encoding()
935
gecos = w.pw_gecos.decode(encoding)
937
raise errors.BzrCommandError('Unable to determine your name. '
938
'Use "bzr whoami" to set it.')
940
username = w.pw_name.decode(encoding)
942
raise errors.BzrCommandError('Unable to determine your name. '
943
'Use "bzr whoami" to set it.')
945
comma = gecos.find(',')
949
realname = gecos[:comma]
956
user_encoding = osutils.get_user_encoding()
957
realname = username = getpass.getuser().decode(user_encoding)
958
except UnicodeDecodeError:
959
raise errors.BzrError("Can't decode username as %s." % \
962
return realname, (username + '@' + socket.gethostname())
965
1210
def parse_username(username):
966
1211
"""Parse e-mail username and return a (name, address) tuple."""
967
1212
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1507
1775
return StringIO()
1509
1777
def _get_configobj(self):
1510
return ConfigObj(self._get_config_file(), encoding='utf-8')
1778
f = self._get_config_file()
1780
return ConfigObj(f, encoding='utf-8')
1512
1784
def _set_configobj(self, configobj):
1513
1785
out_file = StringIO()
1514
1786
configobj.write(out_file)
1515
1787
out_file.seek(0)
1516
1788
self._transport.put_file(self._filename, out_file)
1791
class cmd_config(commands.Command):
1792
__doc__ = """Display, set or remove a configuration option.
1794
Display the active value for a given option.
1796
If --all is specified, NAME is interpreted as a regular expression and all
1797
matching options are displayed mentioning their scope. The active value
1798
that bzr will take into account is the first one displayed for each option.
1800
If no NAME is given, --all .* is implied.
1802
Setting a value is achieved by using name=value without spaces. The value
1803
is set in the most relevant scope and can be checked by displaying the
1807
takes_args = ['name?']
1811
# FIXME: This should be a registry option so that plugins can register
1812
# their own config files (or not) -- vila 20101002
1813
commands.Option('scope', help='Reduce the scope to the specified'
1814
' configuration file',
1816
commands.Option('all',
1817
help='Display all the defined values for the matching options.',
1819
commands.Option('remove', help='Remove the option from'
1820
' the configuration file'),
1823
@commands.display_command
1824
def run(self, name=None, all=False, directory=None, scope=None,
1826
if directory is None:
1828
directory = urlutils.normalize_url(directory)
1830
raise errors.BzrError(
1831
'--all and --remove are mutually exclusive.')
1833
# Delete the option in the given scope
1834
self._remove_config_option(name, directory, scope)
1836
# Defaults to all options
1837
self._show_matching_options('.*', directory, scope)
1840
name, value = name.split('=', 1)
1842
# Display the option(s) value(s)
1844
self._show_matching_options(name, directory, scope)
1846
self._show_value(name, directory, scope)
1849
raise errors.BzrError(
1850
'Only one option can be set.')
1851
# Set the option value
1852
self._set_config_option(name, value, directory, scope)
1854
def _get_configs(self, directory, scope=None):
1855
"""Iterate the configurations specified by ``directory`` and ``scope``.
1857
:param directory: Where the configurations are derived from.
1859
:param scope: A specific config to start from.
1861
if scope is not None:
1862
if scope == 'bazaar':
1863
yield GlobalConfig()
1864
elif scope == 'locations':
1865
yield LocationConfig(directory)
1866
elif scope == 'branch':
1867
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1869
yield br.get_config()
1872
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1874
yield br.get_config()
1875
except errors.NotBranchError:
1876
yield LocationConfig(directory)
1877
yield GlobalConfig()
1879
def _show_value(self, name, directory, scope):
1881
for c in self._get_configs(directory, scope):
1884
for (oname, value, section, conf_id, parser) in c._get_options():
1886
# Display only the first value and exit
1888
# FIXME: We need to use get_user_option to take policies
1889
# into account and we need to make sure the option exists
1890
# too (hence the two for loops), this needs a better API
1892
value = c.get_user_option(name)
1893
# Quote the value appropriately
1894
value = parser._quote(value)
1895
self.outf.write('%s\n' % (value,))
1899
raise errors.NoSuchConfigOption(name)
1901
def _show_matching_options(self, name, directory, scope):
1902
name = re.compile(name)
1903
# We want any error in the regexp to be raised *now* so we need to
1904
# avoid the delay introduced by the lazy regexp.
1905
name._compile_and_collapse()
1908
for c in self._get_configs(directory, scope):
1909
for (oname, value, section, conf_id, parser) in c._get_options():
1910
if name.search(oname):
1911
if cur_conf_id != conf_id:
1912
# Explain where the options are defined
1913
self.outf.write('%s:\n' % (conf_id,))
1914
cur_conf_id = conf_id
1916
if (section not in (None, 'DEFAULT')
1917
and cur_section != section):
1918
# Display the section if it's not the default (or only)
1920
self.outf.write(' [%s]\n' % (section,))
1921
cur_section = section
1922
self.outf.write(' %s = %s\n' % (oname, value))
1924
def _set_config_option(self, name, value, directory, scope):
1925
for conf in self._get_configs(directory, scope):
1926
conf.set_user_option(name, value)
1929
raise errors.NoSuchConfig(scope)
1931
def _remove_config_option(self, name, directory, scope):
1933
raise errors.BzrCommandError(
1934
'--remove expects an option to remove.')
1936
for conf in self._get_configs(directory, scope):
1937
for (section_name, section, conf_id) in conf._get_sections():
1938
if scope is not None and conf_id != scope:
1939
# Not the right configuration file
1942
if conf_id != conf.config_id():
1943
conf = self._get_configs(directory, conf_id).next()
1944
# We use the first section in the first config where the
1945
# option is defined to remove it
1946
conf.remove_user_option(name, section_name)
1951
raise errors.NoSuchConfig(scope)
1953
raise errors.NoSuchConfigOption(name)
added
removed
bzrlib/config.py
