539
126
return CHECK_IF_POSSIBLE
541
@deprecated_method(deprecated_in((2, 5, 0)))
542
def signing_policy(self):
543
"""What is the current policy for signature checking?."""
544
policy = self._get_signing_policy()
545
if policy is not None:
547
return SIGN_WHEN_REQUIRED
549
@deprecated_method(deprecated_in((2, 5, 0)))
550
128
def signature_needed(self):
551
129
"""Is a signature needed when committing ?."""
552
policy = self._get_signing_policy()
554
policy = self._get_signature_checking()
555
if policy is not None:
556
#this warning should go away once check_signatures is
557
#implemented (if not before)
558
trace.warning("Please use create_signatures,"
559
" not check_signatures to set signing policy.")
560
elif policy == SIGN_ALWAYS:
130
policy = self._get_signature_checking()
131
if policy == CHECK_ALWAYS:
564
@deprecated_method(deprecated_in((2, 5, 0)))
565
def gpg_signing_key(self):
566
"""GPG user-id to sign commits"""
567
key = self.get_user_option('gpg_signing_key')
568
if key == "default" or key == None:
569
return self.user_email()
573
def get_alias(self, value):
574
return self._get_alias(value)
576
def _get_alias(self, value):
579
def get_nickname(self):
580
return self._get_nickname()
582
def _get_nickname(self):
585
def get_bzr_remote_path(self):
587
return os.environ['BZR_REMOTE_PATH']
589
path = self.get_user_option("bzr_remote_path")
594
def suppress_warning(self, warning):
595
"""Should the warning be suppressed or emitted.
597
:param warning: The name of the warning being tested.
599
:returns: True if the warning should be suppressed, False otherwise.
601
warnings = self.get_user_option_as_list('suppress_warnings')
602
if warnings is None or warning not in warnings:
607
def get_merge_tools(self):
609
for (oname, value, section, conf_id, parser) in self._get_options():
610
if oname.startswith('bzr.mergetool.'):
611
tool_name = oname[len('bzr.mergetool.'):]
612
tools[tool_name] = self.get_user_option(oname, False)
613
trace.mutter('loaded merge tools: %r' % tools)
616
def find_merge_tool(self, name):
617
# We fake a defaults mechanism here by checking if the given name can
618
# be found in the known_merge_tools if it's not found in the config.
619
# This should be done through the proposed config defaults mechanism
620
# when it becomes available in the future.
621
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
623
or mergetools.known_merge_tools.get(name, None))
627
class _ConfigHooks(hooks.Hooks):
628
"""A dict mapping hook names and a list of callables for configs.
632
"""Create the default hooks.
634
These are all empty initially, because by default nothing should get
637
super(_ConfigHooks, self).__init__('bzrlib.config', 'ConfigHooks')
638
self.add_hook('load',
639
'Invoked when a config store is loaded.'
640
' The signature is (store).',
642
self.add_hook('save',
643
'Invoked when a config store is saved.'
644
' The signature is (store).',
646
# The hooks for config options
648
'Invoked when a config option is read.'
649
' The signature is (stack, name, value).',
652
'Invoked when a config option is set.'
653
' The signature is (stack, name, value).',
655
self.add_hook('remove',
656
'Invoked when a config option is removed.'
657
' The signature is (stack, name).',
659
ConfigHooks = _ConfigHooks()
662
class _OldConfigHooks(hooks.Hooks):
663
"""A dict mapping hook names and a list of callables for configs.
667
"""Create the default hooks.
669
These are all empty initially, because by default nothing should get
672
super(_OldConfigHooks, self).__init__('bzrlib.config', 'OldConfigHooks')
673
self.add_hook('load',
674
'Invoked when a config store is loaded.'
675
' The signature is (config).',
677
self.add_hook('save',
678
'Invoked when a config store is saved.'
679
' The signature is (config).',
681
# The hooks for config options
683
'Invoked when a config option is read.'
684
' The signature is (config, name, value).',
687
'Invoked when a config option is set.'
688
' The signature is (config, name, value).',
690
self.add_hook('remove',
691
'Invoked when a config option is removed.'
692
' The signature is (config, name).',
694
OldConfigHooks = _OldConfigHooks()
697
136
class IniBasedConfig(Config):
698
137
"""A configuration policy that draws from ini files."""
700
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
702
"""Base class for configuration files using an ini-like syntax.
704
:param file_name: The configuration file path.
706
super(IniBasedConfig, self).__init__()
707
self.file_name = file_name
708
if symbol_versioning.deprecated_passed(get_filename):
709
symbol_versioning.warn(
710
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
711
' Use file_name instead.',
714
if get_filename is not None:
715
self.file_name = get_filename()
717
self.file_name = file_name
722
def from_string(cls, str_or_unicode, file_name=None, save=False):
723
"""Create a config object from a string.
725
:param str_or_unicode: A string representing the file content. This will
728
:param file_name: The configuration file path.
730
:param _save: Whether the file should be saved upon creation.
732
conf = cls(file_name=file_name)
733
conf._create_from_string(str_or_unicode, save)
736
def _create_from_string(self, str_or_unicode, save):
737
self._content = StringIO(str_or_unicode.encode('utf-8'))
738
# Some tests use in-memory configs, some other always need the config
739
# file to exist on disk.
741
self._write_config_file()
743
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
744
if self._parser is not None:
746
if symbol_versioning.deprecated_passed(file):
747
symbol_versioning.warn(
748
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
749
' Use IniBasedConfig(_content=xxx) instead.',
752
if self._content is not None:
753
co_input = self._content
754
elif self.file_name is None:
755
raise AssertionError('We have no content to create the config')
757
co_input = self.file_name
759
self._parser = ConfigObj(co_input, encoding='utf-8')
760
except configobj.ConfigObjError, e:
761
raise errors.ParseConfigError(e.errors, e.config.filename)
762
except UnicodeDecodeError:
763
raise errors.ConfigContentError(self.file_name)
764
# Make sure self.reload() will use the right file name
765
self._parser.filename = self.file_name
766
for hook in OldConfigHooks['load']:
139
def _get_parser(self, file=None):
141
input = self._get_filename()
144
if self._parser is None:
146
self._parser = ConfigObj(input)
147
except ConfigObjError, e:
148
raise errors.ParseConfigError(e.errors, e.config.filename)
768
149
return self._parser
771
"""Reload the config file from disk."""
772
if self.file_name is None:
773
raise AssertionError('We need a file name to reload the config')
774
if self._parser is not None:
775
self._parser.reload()
776
for hook in ConfigHooks['load']:
779
def _get_matching_sections(self):
780
"""Return an ordered list of (section_name, extra_path) pairs.
782
If the section contains inherited configuration, extra_path is
783
a string containing the additional path components.
785
section = self._get_section()
786
if section is not None:
787
return [(section, '')]
791
151
def _get_section(self):
792
152
"""Override this to define the section used by the config."""
795
def _get_sections(self, name=None):
796
"""Returns an iterator of the sections specified by ``name``.
798
:param name: The section name. If None is supplied, the default
799
configurations are yielded.
801
:return: A tuple (name, section, config_id) for all sections that will
802
be walked by user_get_option() in the 'right' order. The first one
803
is where set_user_option() will update the value.
805
parser = self._get_parser()
807
yield (name, parser[name], self.config_id())
155
def _config_val(self, name, section=None):
157
section = self._get_section()
160
# Throw KeyError if name or section not present
161
if section == "DEFAULT":
163
return self._get_parser()[name]
166
return self._get_parser()[section][name]
168
def _config_bool(self, name, section=None):
169
val = self._config_val(name, section).lower()
170
if val in ('1', 'yes', 'true', 'on'):
172
elif val in ('0', 'no', 'false', 'off'):
809
# No section name has been given so we fallback to the configobj
810
# itself which holds the variables defined outside of any section.
811
yield (None, parser, self.config_id())
813
def _get_options(self, sections=None):
814
"""Return an ordered list of (name, value, section, config_id) tuples.
816
All options are returned with their associated value and the section
817
they appeared in. ``config_id`` is a unique identifier for the
818
configuration file the option is defined in.
820
:param sections: Default to ``_get_matching_sections`` if not
821
specified. This gives a better control to daughter classes about
822
which sections should be searched. This is a list of (name,
827
parser = self._get_parser()
829
for (section_name, _) in self._get_matching_sections():
831
section = parser[section_name]
833
# This could happen for an empty file for which we define a
834
# DEFAULT section. FIXME: Force callers to provide sections
835
# instead ? -- vila 20100930
837
sections.append((section_name, section))
838
config_id = self.config_id()
839
for (section_name, section) in sections:
840
for (name, value) in section.iteritems():
841
yield (name, parser._quote(value), section_name,
844
def _get_option_policy(self, section, option_name):
845
"""Return the policy for the given (section, option_name) pair."""
848
def _get_change_editor(self):
849
return self.get_user_option('change_editor')
175
raise ValueError("Value %r is not boolean" % val)
851
179
def _get_signature_checking(self):
852
180
"""See Config._get_signature_checking."""
853
policy = self._get_user_option('check_signatures')
855
return signature_policy_from_unicode(policy)
857
def _get_signing_policy(self):
858
"""See Config._get_signing_policy"""
859
policy = self._get_user_option('create_signatures')
861
return signing_policy_from_unicode(policy)
182
policy = self._config_val('check_signatures')
185
return self._string_to_signature_policy(policy)
863
187
def _get_user_id(self):
864
188
"""Get the user id from the 'email' key in the current section."""
865
return self._get_user_option('email')
867
def _get_user_option(self, option_name):
868
"""See Config._get_user_option."""
869
for (section, extra_path) in self._get_matching_sections():
871
value = self._get_parser().get_value(section, option_name)
874
policy = self._get_option_policy(section, option_name)
875
if policy == POLICY_NONE:
877
elif policy == POLICY_NORECURSE:
878
# norecurse items only apply to the exact path
883
elif policy == POLICY_APPENDPATH:
885
value = urlutils.join(value, extra_path)
888
raise AssertionError('Unexpected config policy %r' % policy)
892
def _gpg_signing_command(self):
893
"""See Config.gpg_signing_command."""
894
return self._get_user_option('gpg_signing_command')
896
def _log_format(self):
897
"""See Config.log_format."""
898
return self._get_user_option('log_format')
900
def _validate_signatures_in_log(self):
901
"""See Config.validate_signatures_in_log."""
902
return self._get_user_option('validate_signatures_in_log')
904
def _acceptable_keys(self):
905
"""See Config.acceptable_keys."""
906
return self._get_user_option('acceptable_keys')
908
def _post_commit(self):
909
"""See Config.post_commit."""
910
return self._get_user_option('post_commit')
912
def _get_alias(self, value):
914
return self._get_parser().get_value("ALIASES",
190
return self._config_val('email')
919
def _get_nickname(self):
920
return self.get_user_option('nickname')
922
def remove_user_option(self, option_name, section_name=None):
923
"""Remove a user option and save the configuration file.
925
:param option_name: The option to be removed.
927
:param section_name: The section the option is defined in, default to
931
parser = self._get_parser()
932
if section_name is None:
935
section = parser[section_name]
937
del section[option_name]
939
raise errors.NoSuchConfigOption(option_name)
940
self._write_config_file()
941
for hook in OldConfigHooks['remove']:
942
hook(self, option_name)
944
def _write_config_file(self):
945
if self.file_name is None:
946
raise AssertionError('We cannot save, self.file_name is None')
947
conf_dir = os.path.dirname(self.file_name)
948
ensure_config_dir_exists(conf_dir)
949
atomic_file = atomicfile.AtomicFile(self.file_name)
950
self._get_parser().write(atomic_file)
953
osutils.copy_ownership_from_path(self.file_name)
954
for hook in OldConfigHooks['save']:
958
class LockableConfig(IniBasedConfig):
959
"""A configuration needing explicit locking for access.
961
If several processes try to write the config file, the accesses need to be
964
Daughter classes should decorate all methods that update a config with the
965
``@needs_write_lock`` decorator (they call, directly or indirectly, the
966
``_write_config_file()`` method. These methods (typically ``set_option()``
967
and variants must reload the config file from disk before calling
968
``_write_config_file()``), this can be achieved by calling the
969
``self.reload()`` method. Note that the lock scope should cover both the
970
reading and the writing of the config file which is why the decorator can't
971
be applied to ``_write_config_file()`` only.
973
This should be enough to implement the following logic:
974
- lock for exclusive write access,
975
- reload the config file from disk,
979
This logic guarantees that a writer can update a value without erasing an
980
update made by another writer.
985
def __init__(self, file_name):
986
super(LockableConfig, self).__init__(file_name=file_name)
987
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
988
# FIXME: It doesn't matter that we don't provide possible_transports
989
# below since this is currently used only for local config files ;
990
# local transports are not shared. But if/when we start using
991
# LockableConfig for other kind of transports, we will need to reuse
992
# whatever connection is already established -- vila 20100929
993
self.transport = transport.get_transport_from_path(self.dir)
994
self._lock = lockdir.LockDir(self.transport, self.lock_name)
996
def _create_from_string(self, unicode_bytes, save):
997
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
999
# We need to handle the saving here (as opposed to IniBasedConfig)
1000
# to be able to lock
1002
self._write_config_file()
1005
def lock_write(self, token=None):
1006
"""Takes a write lock in the directory containing the config file.
1008
If the directory doesn't exist it is created.
1010
ensure_config_dir_exists(self.dir)
1011
return self._lock.lock_write(token)
1016
def break_lock(self):
1017
self._lock.break_lock()
1020
def remove_user_option(self, option_name, section_name=None):
1021
super(LockableConfig, self).remove_user_option(option_name,
1024
def _write_config_file(self):
1025
if self._lock is None or not self._lock.is_held:
1026
# NB: if the following exception is raised it probably means a
1027
# missing @needs_write_lock decorator on one of the callers.
1028
raise errors.ObjectNotLocked(self)
1029
super(LockableConfig, self)._write_config_file()
1032
class GlobalConfig(LockableConfig):
194
def __init__(self, get_filename):
195
super(IniBasedConfig, self).__init__()
196
self._get_filename = get_filename
199
def _string_to_signature_policy(self, signature_string):
200
"""Convert a string to a signing policy."""
201
if signature_string.lower() == 'check-available':
202
return CHECK_IF_POSSIBLE
203
if signature_string.lower() == 'ignore':
205
if signature_string.lower() == 'require':
207
raise errors.BzrError("Invalid signatures policy '%s'"
211
class GlobalConfig(IniBasedConfig):
1033
212
"""The configuration that should be used for a specific location."""
214
def get_editor(self):
216
return self._config_val('editor')
1035
220
def __init__(self):
1036
super(GlobalConfig, self).__init__(file_name=config_filename())
1038
def config_id(self):
1042
def from_string(cls, str_or_unicode, save=False):
1043
"""Create a config object from a string.
1045
:param str_or_unicode: A string representing the file content. This
1046
will be utf-8 encoded.
1048
:param save: Whether the file should be saved upon creation.
221
super(GlobalConfig, self).__init__(config_filename)
224
class LocationConfig(IniBasedConfig):
225
"""A configuration object that gives the policy for a location."""
227
def __init__(self, location):
228
super(LocationConfig, self).__init__(branches_config_filename)
229
self._global_config = None
230
self.location = location
232
def _get_global_config(self):
233
if self._global_config is None:
234
self._global_config = GlobalConfig()
235
return self._global_config
237
def _get_section(self):
238
"""Get the section we should look in for config items.
240
Returns None if none exists.
241
TODO: perhaps return a NullSection that thunks through to the
1051
conf._create_from_string(str_or_unicode, save)
1055
def set_user_option(self, option, value):
1056
"""Save option and its value in the configuration."""
1057
self._set_option(option, value, 'DEFAULT')
1059
def get_aliases(self):
1060
"""Return the aliases section."""
1061
if 'ALIASES' in self._get_parser():
1062
return self._get_parser()['ALIASES']
1067
def set_alias(self, alias_name, alias_command):
1068
"""Save the alias in the configuration."""
1069
self._set_option(alias_name, alias_command, 'ALIASES')
1072
def unset_alias(self, alias_name):
1073
"""Unset an existing alias."""
1075
aliases = self._get_parser().get('ALIASES')
1076
if not aliases or alias_name not in aliases:
1077
raise errors.NoSuchAlias(alias_name)
1078
del aliases[alias_name]
1079
self._write_config_file()
1081
def _set_option(self, option, value, section):
1083
self._get_parser().setdefault(section, {})[option] = value
1084
self._write_config_file()
1085
for hook in OldConfigHooks['set']:
1086
hook(self, option, value)
1088
def _get_sections(self, name=None):
1089
"""See IniBasedConfig._get_sections()."""
1090
parser = self._get_parser()
1091
# We don't give access to options defined outside of any section, we
1092
# used the DEFAULT section by... default.
1093
if name in (None, 'DEFAULT'):
1094
# This could happen for an empty file where the DEFAULT section
1095
# doesn't exist yet. So we force DEFAULT when yielding
1097
if 'DEFAULT' not in parser:
1098
parser['DEFAULT']= {}
1099
yield (name, parser[name], self.config_id())
1102
def remove_user_option(self, option_name, section_name=None):
1103
if section_name is None:
1104
# We need to force the default section.
1105
section_name = 'DEFAULT'
1106
# We need to avoid the LockableConfig implementation or we'll lock
1108
super(LockableConfig, self).remove_user_option(option_name,
1111
def _iter_for_location_by_parts(sections, location):
1112
"""Keep only the sessions matching the specified location.
1114
:param sections: An iterable of section names.
1116
:param location: An url or a local path to match against.
1118
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
1119
number of path components in the section name, section is the section
1120
name and extra_path is the difference between location and the section
1123
``location`` will always be a local path and never a 'file://' url but the
1124
section names themselves can be in either form.
1126
location_parts = location.rstrip('/').split('/')
1128
for section in sections:
1129
# location is a local path if possible, so we need to convert 'file://'
1130
# urls in section names to local paths if necessary.
1132
# This also avoids having file:///path be a more exact
1133
# match than '/path'.
1135
# FIXME: This still raises an issue if a user defines both file:///path
1136
# *and* /path. Should we raise an error in this case -- vila 20110505
1138
if section.startswith('file://'):
1139
section_path = urlutils.local_path_from_url(section)
1141
section_path = section
1142
section_parts = section_path.rstrip('/').split('/')
1145
if len(section_parts) > len(location_parts):
1146
# More path components in the section, they can't match
1149
# Rely on zip truncating in length to the length of the shortest
1150
# argument sequence.
1151
names = zip(location_parts, section_parts)
244
sections = self._get_parser()
245
location_names = self.location.split('/')
246
if self.location.endswith('/'):
247
del location_names[-1]
249
for section in sections:
250
section_names = section.split('/')
251
if section.endswith('/'):
252
del section_names[-1]
253
names = zip(location_names, section_names)
1152
255
for name in names:
1153
if not fnmatch.fnmatch(name[0], name[1]):
256
if not fnmatch(name[0], name[1]):
1158
# build the path difference between the section and the location
1159
extra_path = '/'.join(location_parts[len(section_parts):])
1160
yield section, extra_path, len(section_parts)
1163
class LocationConfig(LockableConfig):
1164
"""A configuration object that gives the policy for a location."""
1166
def __init__(self, location):
1167
super(LocationConfig, self).__init__(
1168
file_name=locations_config_filename())
1169
# local file locations are looked up by local path, rather than
1170
# by file url. This is because the config file is a user
1171
# file, and we would rather not expose the user to file urls.
1172
if location.startswith('file://'):
1173
location = urlutils.local_path_from_url(location)
1174
self.location = location
1176
def config_id(self):
1180
def from_string(cls, str_or_unicode, location, save=False):
1181
"""Create a config object from a string.
1183
:param str_or_unicode: A string representing the file content. This will
1186
:param location: The location url to filter the configuration.
1188
:param save: Whether the file should be saved upon creation.
1190
conf = cls(location)
1191
conf._create_from_string(str_or_unicode, save)
1194
def _get_matching_sections(self):
1195
"""Return an ordered list of section names matching this location."""
1196
matches = list(_iter_for_location_by_parts(self._get_parser(),
1198
# put the longest (aka more specific) locations first
1200
key=lambda (section, extra_path, length): (length, section),
1202
for (section, extra_path, length) in matches:
1203
yield section, extra_path
1204
# should we stop looking for parent configs here?
1206
if self._get_parser()[section].as_bool('ignore_parents'):
1211
def _get_sections(self, name=None):
1212
"""See IniBasedConfig._get_sections()."""
1213
# We ignore the name here as the only sections handled are named with
1214
# the location path and we don't expose embedded sections either.
1215
parser = self._get_parser()
1216
for name, extra_path in self._get_matching_sections():
1217
yield (name, parser[name], self.config_id())
1219
def _get_option_policy(self, section, option_name):
1220
"""Return the policy for the given (section, option_name) pair."""
1221
# check for the old 'recurse=False' flag
1223
recurse = self._get_parser()[section].as_bool('recurse')
1227
return POLICY_NORECURSE
1229
policy_key = option_name + ':policy'
1231
policy_name = self._get_parser()[section][policy_key]
1235
return _policy_value[policy_name]
1237
def _set_option_policy(self, section, option_name, option_policy):
1238
"""Set the policy for the given option name in the given section."""
1239
# The old recurse=False option affects all options in the
1240
# section. To handle multiple policies in the section, we
1241
# need to convert it to a policy_norecurse key.
1243
recurse = self._get_parser()[section].as_bool('recurse')
1247
symbol_versioning.warn(
1248
'The recurse option is deprecated as of 0.14. '
1249
'The section "%s" has been converted to use policies.'
1252
del self._get_parser()[section]['recurse']
1254
for key in self._get_parser()[section].keys():
1255
if not key.endswith(':policy'):
1256
self._get_parser()[section][key +
1257
':policy'] = 'norecurse'
1259
policy_key = option_name + ':policy'
1260
policy_name = _policy_name[option_policy]
1261
if policy_name is not None:
1262
self._get_parser()[section][policy_key] = policy_name
1264
if policy_key in self._get_parser()[section]:
1265
del self._get_parser()[section][policy_key]
1268
def set_user_option(self, option, value, store=STORE_LOCATION):
1269
"""Save option and its value in the configuration."""
1270
if store not in [STORE_LOCATION,
1271
STORE_LOCATION_NORECURSE,
1272
STORE_LOCATION_APPENDPATH]:
1273
raise ValueError('bad storage policy %r for %r' %
1276
location = self.location
1277
if location.endswith('/'):
1278
location = location[:-1]
1279
parser = self._get_parser()
1280
if not location in parser and not location + '/' in parser:
1281
parser[location] = {}
1282
elif location + '/' in parser:
1283
location = location + '/'
1284
parser[location][option]=value
1285
# the allowed values of store match the config policies
1286
self._set_option_policy(location, option, store)
1287
self._write_config_file()
1288
for hook in OldConfigHooks['set']:
1289
hook(self, option, value)
261
# so, for the common prefix they matched.
262
# if section is longer, no match.
263
if len(section_names) > len(location_names):
265
# if path is longer, and recurse is not true, no match
266
if len(section_names) < len(location_names):
268
if not self._config_bool('recurse', section=section):
272
matches.append((len(section_names), section))
275
matches.sort(reverse=True)
278
def _get_user_id(self):
279
user_id = super(LocationConfig, self)._get_user_id()
280
if user_id is not None:
282
return self._get_global_config()._get_user_id()
284
def _get_signature_checking(self):
285
"""See Config._get_signature_checking."""
286
check = super(LocationConfig, self)._get_signature_checking()
287
if check is not None:
289
return self._get_global_config()._get_signature_checking()
1292
292
class BranchConfig(Config):
1293
293
"""A configuration object giving the policy for a branch."""
1295
def __init__(self, branch):
1296
super(BranchConfig, self).__init__()
1297
self._location_config = None
1298
self._branch_data_config = None
1299
self._global_config = None
1300
self.branch = branch
1301
self.option_sources = (self._get_location_config,
1302
self._get_branch_data_config,
1303
self._get_global_config)
1305
def config_id(self):
1308
def _get_branch_data_config(self):
1309
if self._branch_data_config is None:
1310
self._branch_data_config = TreeConfig(self.branch)
1311
self._branch_data_config.config_id = self.config_id
1312
return self._branch_data_config
1314
295
def _get_location_config(self):
1315
296
if self._location_config is None:
1316
297
self._location_config = LocationConfig(self.branch.base)
1317
298
return self._location_config
1319
def _get_global_config(self):
1320
if self._global_config is None:
1321
self._global_config = GlobalConfig()
1322
return self._global_config
1324
def _get_best_value(self, option_name):
1325
"""This returns a user option from local, tree or global config.
1327
They are tried in that order. Use get_safe_value if trusted values
1330
for source in self.option_sources:
1331
value = getattr(source(), option_name)()
1332
if value is not None:
1336
def _get_safe_value(self, option_name):
1337
"""This variant of get_best_value never returns untrusted values.
1339
It does not return values from the branch data, because the branch may
1340
not be controlled by the user.
1342
We may wish to allow locations.conf to control whether branches are
1343
trusted in the future.
1345
for source in (self._get_location_config, self._get_global_config):
1346
value = getattr(source(), option_name)()
1347
if value is not None:
1351
300
def _get_user_id(self):
1352
301
"""Return the full user id for the branch.
1354
e.g. "John Hacker <jhacker@example.com>"
303
e.g. "John Hacker <jhacker@foo.org>"
1355
304
This is looked up in the email controlfile for the branch.
1357
return self._get_best_value('_get_user_id')
1359
def _get_change_editor(self):
1360
return self._get_best_value('_get_change_editor')
307
return (self.branch.controlfile("email", "r")
309
.decode(bzrlib.user_encoding)
311
except errors.NoSuchFile, e:
314
return self._get_location_config()._get_user_id()
1362
316
def _get_signature_checking(self):
1363
317
"""See Config._get_signature_checking."""
1364
return self._get_best_value('_get_signature_checking')
1366
def _get_signing_policy(self):
1367
"""See Config._get_signing_policy."""
1368
return self._get_best_value('_get_signing_policy')
1370
def _get_user_option(self, option_name):
1371
"""See Config._get_user_option."""
1372
for source in self.option_sources:
1373
value = source()._get_user_option(option_name)
1374
if value is not None:
1378
def _get_sections(self, name=None):
1379
"""See IniBasedConfig.get_sections()."""
1380
for source in self.option_sources:
1381
for section in source()._get_sections(name):
1384
def _get_options(self, sections=None):
1386
# First the locations options
1387
for option in self._get_location_config()._get_options():
1389
# Then the branch options
1390
branch_config = self._get_branch_data_config()
1391
if sections is None:
1392
sections = [('DEFAULT', branch_config._get_parser())]
1393
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1394
# Config itself has no notion of sections :( -- vila 20101001
1395
config_id = self.config_id()
1396
for (section_name, section) in sections:
1397
for (name, value) in section.iteritems():
1398
yield (name, value, section_name,
1399
config_id, branch_config._get_parser())
1400
# Then the global options
1401
for option in self._get_global_config()._get_options():
1404
def set_user_option(self, name, value, store=STORE_BRANCH,
1406
if store == STORE_BRANCH:
1407
self._get_branch_data_config().set_option(value, name)
1408
elif store == STORE_GLOBAL:
1409
self._get_global_config().set_user_option(name, value)
1411
self._get_location_config().set_user_option(name, value, store)
1414
if store in (STORE_GLOBAL, STORE_BRANCH):
1415
mask_value = self._get_location_config().get_user_option(name)
1416
if mask_value is not None:
1417
trace.warning('Value "%s" is masked by "%s" from'
1418
' locations.conf', value, mask_value)
1420
if store == STORE_GLOBAL:
1421
branch_config = self._get_branch_data_config()
1422
mask_value = branch_config.get_user_option(name)
1423
if mask_value is not None:
1424
trace.warning('Value "%s" is masked by "%s" from'
1425
' branch.conf', value, mask_value)
1427
def remove_user_option(self, option_name, section_name=None):
1428
self._get_branch_data_config().remove_option(option_name, section_name)
1430
def _gpg_signing_command(self):
1431
"""See Config.gpg_signing_command."""
1432
return self._get_safe_value('_gpg_signing_command')
1434
def _post_commit(self):
1435
"""See Config.post_commit."""
1436
return self._get_safe_value('_post_commit')
1438
def _get_nickname(self):
1439
value = self._get_explicit_nickname()
1440
if value is not None:
1442
if self.branch.name:
1443
return self.branch.name
1444
return urlutils.unescape(self.branch.base.split('/')[-2])
1446
def has_explicit_nickname(self):
1447
"""Return true if a nickname has been explicitly assigned."""
1448
return self._get_explicit_nickname() is not None
1450
def _get_explicit_nickname(self):
1451
return self._get_best_value('_get_nickname')
1453
def _log_format(self):
1454
"""See Config.log_format."""
1455
return self._get_best_value('_log_format')
1457
def _validate_signatures_in_log(self):
1458
"""See Config.validate_signatures_in_log."""
1459
return self._get_best_value('_validate_signatures_in_log')
1461
def _acceptable_keys(self):
1462
"""See Config.acceptable_keys."""
1463
return self._get_best_value('_acceptable_keys')
1466
def ensure_config_dir_exists(path=None):
1467
"""Make sure a configuration directory exists.
1468
This makes sure that the directory exists.
1469
On windows, since configuration directories are 2 levels deep,
1470
it makes sure both the directory and the parent directory exists.
1474
if not os.path.isdir(path):
1475
if sys.platform == 'win32':
1476
parent_dir = os.path.dirname(path)
1477
if not os.path.isdir(parent_dir):
1478
trace.mutter('creating config parent directory: %r', parent_dir)
1479
os.mkdir(parent_dir)
1480
trace.mutter('creating config directory: %r', path)
1482
osutils.copy_ownership_from_path(path)
318
return self._get_location_config()._get_signature_checking()
320
def __init__(self, branch):
321
super(BranchConfig, self).__init__()
322
self._location_config = None
1485
326
def config_dir():
1486
"""Return per-user configuration directory as unicode string
1488
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1489
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1490
that will be used instead.
327
"""Return per-user configuration directory.
329
By default this is ~/.bazaar/
1492
331
TODO: Global option --config-dir to override this.
1494
base = osutils.path_from_environ('BZR_HOME')
1495
if sys.platform == 'win32':
1497
base = win32utils.get_appdata_location()
1499
base = win32utils.get_home_location()
1500
# GZ 2012-02-01: Really the two level subdirs only make sense inside
1501
# APPDATA, but hard to move. See bug 348640 for more.
1502
return osutils.pathjoin(base, 'bazaar', '2.0')
1504
# GZ 2012-02-01: What should OSX use instead of XDG if anything?
1505
if sys.platform != 'darwin':
1506
xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1508
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1509
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1510
if osutils.isdir(xdg_dir):
1512
"Using configuration in XDG directory %s." % xdg_dir)
1514
base = osutils._get_home_dir()
1515
return osutils.pathjoin(base, ".bazaar")
333
return os.path.join(os.path.expanduser("~"), ".bazaar")
1518
336
def config_filename():
1519
337
"""Return per-user configuration ini file filename."""
1520
return osutils.pathjoin(config_dir(), 'bazaar.conf')
1523
def locations_config_filename():
338
return os.path.join(config_dir(), 'bazaar.conf')
341
def branches_config_filename():
1524
342
"""Return per-user configuration ini file filename."""
1525
return osutils.pathjoin(config_dir(), 'locations.conf')
1528
def authentication_config_filename():
1529
"""Return per-user authentication ini file filename."""
1530
return osutils.pathjoin(config_dir(), 'authentication.conf')
1533
def user_ignore_config_filename():
1534
"""Return the user default ignore filename"""
1535
return osutils.pathjoin(config_dir(), 'ignore')
1539
"""Return the directory name to store crash files.
1541
This doesn't implicitly create it.
1543
On Windows it's in the config directory; elsewhere it's /var/crash
1544
which may be monitored by apport. It can be overridden by
1547
if sys.platform == 'win32':
1548
return osutils.pathjoin(config_dir(), 'Crash')
1550
# XXX: hardcoded in apport_python_hook.py; therefore here too -- mbp
1552
return os.environ.get('APPORT_CRASH_DIR', '/var/crash')
1555
def xdg_cache_dir():
1556
# See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1557
# Possibly this should be different on Windows?
1558
e = os.environ.get('XDG_CACHE_DIR', None)
1562
return os.path.expanduser('~/.cache')
1565
def _get_default_mail_domain():
1566
"""If possible, return the assumed default email domain.
1568
:returns: string mail domain, or None.
1570
if sys.platform == 'win32':
1571
# No implementation yet; patches welcome
1574
f = open('/etc/mailname')
1575
except (IOError, OSError), e:
1578
domain = f.read().strip()
1584
def default_email():
1585
v = os.environ.get('BZR_EMAIL')
1587
return v.decode(osutils.get_user_encoding())
1588
v = os.environ.get('EMAIL')
1590
return v.decode(osutils.get_user_encoding())
1591
name, email = _auto_user_id()
1593
return u'%s <%s>' % (name, email)
1596
raise errors.NoWhoami()
343
return os.path.join(config_dir(), 'branches.conf')
1599
346
def _auto_user_id():
1600
347
"""Calculate automatic user identification.
1602
:returns: (realname, email), either of which may be None if they can't be
349
Returns (realname, email).
1605
351
Only used when none is set in the environment or the id file.
1607
This only returns an email address if we can be fairly sure the
1608
address is reasonable, ie if /etc/mailname is set on unix.
1610
This doesn't use the FQDN as the default domain because that may be
1611
slow, and it doesn't use the hostname alone because that's not normally
1612
a reasonable address.
353
This previously used the FQDN as the default domain, but that can
354
be very slow on machines where DNS is broken. So now we simply
1614
if sys.platform == 'win32':
1615
# No implementation to reliably determine Windows default mail
1616
# address; please add one.
1619
default_mail_domain = _get_default_mail_domain()
1620
if not default_mail_domain:
359
# XXX: Any good way to get real user name on win32?
1626
364
w = pwd.getpwuid(uid)
1628
trace.mutter('no passwd entry for uid %d?' % uid)
1631
# we try utf-8 first, because on many variants (like Linux),
1632
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1633
# false positives. (many users will have their user encoding set to
1634
# latin-1, which cannot raise UnicodeError.)
1636
gecos = w.pw_gecos.decode('utf-8')
1638
except UnicodeError:
1640
encoding = osutils.get_user_encoding()
1641
gecos = w.pw_gecos.decode(encoding)
1642
except UnicodeError, e:
1643
trace.mutter("cannot decode passwd entry %s" % w)
1646
username = w.pw_name.decode(encoding)
1647
except UnicodeError, e:
1648
trace.mutter("cannot decode passwd entry %s" % w)
1651
comma = gecos.find(',')
1655
realname = gecos[:comma]
1657
return realname, (username + '@' + default_mail_domain)
1660
def parse_username(username):
1661
"""Parse e-mail username and return a (name, address) tuple."""
1662
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1664
return (username, '')
1666
return (match.group(1), match.group(2))
365
gecos = w.pw_gecos.decode(bzrlib.user_encoding)
366
username = w.pw_name.decode(bzrlib.user_encoding)
367
comma = gecos.find(',')
371
realname = gecos[:comma]
377
realname = username = getpass.getuser().decode(bzrlib.user_encoding)
379
return realname, (username + '@' + socket.gethostname())
1669
382
def extract_email_address(e):
1670
383
"""Return just the address part of an email string.
1672
That is just the user@domain part, nothing else.
385
That is just the user@domain part, nothing else.
1673
386
This part is required to contain only ascii characters.
1674
387
If it can't be extracted, raises an error.
1676
389
>>> extract_email_address('Jane Tester <jane@test.com>')
1679
name, email = parse_username(e)
1681
raise errors.NoEmailInUsername(e)
1685
class TreeConfig(IniBasedConfig):
1686
"""Branch configuration data associated with its contents, not location"""
1688
# XXX: Really needs a better name, as this is not part of the tree! -- mbp 20080507
1690
def __init__(self, branch):
1691
self._config = branch._get_config()
1692
self.branch = branch
1694
def _get_parser(self, file=None):
1695
if file is not None:
1696
return IniBasedConfig._get_parser(file)
1697
return self._config._get_configobj()
1699
def get_option(self, name, section=None, default=None):
1700
self.branch.lock_read()
1702
return self._config.get_option(name, section, default)
1704
self.branch.unlock()
1706
def set_option(self, value, name, section=None):
1707
"""Set a per-branch configuration option"""
1708
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1709
# higher levels providing the right lock -- vila 20101004
1710
self.branch.lock_write()
1712
self._config.set_option(value, name, section)
1714
self.branch.unlock()
1716
def remove_option(self, option_name, section_name=None):
1717
# FIXME: We shouldn't need to lock explicitly here but rather rely on
1718
# higher levels providing the right lock -- vila 20101004
1719
self.branch.lock_write()
1721
self._config.remove_option(option_name, section_name)
1723
self.branch.unlock()
1726
class AuthenticationConfig(object):
1727
"""The authentication configuration file based on a ini file.
1729
Implements the authentication.conf file described in
1730
doc/developers/authentication-ring.txt.
1733
def __init__(self, _file=None):
1734
self._config = None # The ConfigObj
1736
self._filename = authentication_config_filename()
1737
self._input = self._filename = authentication_config_filename()
1739
# Tests can provide a string as _file
1740
self._filename = None
1743
def _get_config(self):
1744
if self._config is not None:
1747
# FIXME: Should we validate something here ? Includes: empty
1748
# sections are useless, at least one of
1749
# user/password/password_encoding should be defined, etc.
1751
# Note: the encoding below declares that the file itself is utf-8
1752
# encoded, but the values in the ConfigObj are always Unicode.
1753
self._config = ConfigObj(self._input, encoding='utf-8')
1754
except configobj.ConfigObjError, e:
1755
raise errors.ParseConfigError(e.errors, e.config.filename)
1756
except UnicodeError:
1757
raise errors.ConfigContentError(self._filename)
1761
"""Save the config file, only tests should use it for now."""
1762
conf_dir = os.path.dirname(self._filename)
1763
ensure_config_dir_exists(conf_dir)
1764
f = file(self._filename, 'wb')
1766
self._get_config().write(f)
1770
def _set_option(self, section_name, option_name, value):
1771
"""Set an authentication configuration option"""
1772
conf = self._get_config()
1773
section = conf.get(section_name)
1776
section = conf[section]
1777
section[option_name] = value
1780
def get_credentials(self, scheme, host, port=None, user=None, path=None,
1782
"""Returns the matching credentials from authentication.conf file.
1784
:param scheme: protocol
1786
:param host: the server address
1788
:param port: the associated port (optional)
1790
:param user: login (optional)
1792
:param path: the absolute path on the server (optional)
1794
:param realm: the http authentication realm (optional)
1796
:return: A dict containing the matching credentials or None.
1798
- name: the section name of the credentials in the
1799
authentication.conf file,
1800
- user: can't be different from the provided user if any,
1801
- scheme: the server protocol,
1802
- host: the server address,
1803
- port: the server port (can be None),
1804
- path: the absolute server path (can be None),
1805
- realm: the http specific authentication realm (can be None),
1806
- password: the decoded password, could be None if the credential
1807
defines only the user
1808
- verify_certificates: https specific, True if the server
1809
certificate should be verified, False otherwise.
1812
for auth_def_name, auth_def in self._get_config().items():
1813
if type(auth_def) is not configobj.Section:
1814
raise ValueError("%s defined outside a section" % auth_def_name)
1816
a_scheme, a_host, a_user, a_path = map(
1817
auth_def.get, ['scheme', 'host', 'user', 'path'])
1820
a_port = auth_def.as_int('port')
1824
raise ValueError("'port' not numeric in %s" % auth_def_name)
1826
a_verify_certificates = auth_def.as_bool('verify_certificates')
1828
a_verify_certificates = True
1831
"'verify_certificates' not boolean in %s" % auth_def_name)
1834
if a_scheme is not None and scheme != a_scheme:
1836
if a_host is not None:
1837
if not (host == a_host
1838
or (a_host.startswith('.') and host.endswith(a_host))):
1840
if a_port is not None and port != a_port:
1842
if (a_path is not None and path is not None
1843
and not path.startswith(a_path)):
1845
if (a_user is not None and user is not None
1846
and a_user != user):
1847
# Never contradict the caller about the user to be used
1852
# Prepare a credentials dictionary with additional keys
1853
# for the credential providers
1854
credentials = dict(name=auth_def_name,
1861
password=auth_def.get('password', None),
1862
verify_certificates=a_verify_certificates)
1863
# Decode the password in the credentials (or get one)
1864
self.decode_password(credentials,
1865
auth_def.get('password_encoding', None))
1866
if 'auth' in debug.debug_flags:
1867
trace.mutter("Using authentication section: %r", auth_def_name)
1870
if credentials is None:
1871
# No credentials were found in authentication.conf, try the fallback
1872
# credentials stores.
1873
credentials = credential_store_registry.get_fallback_credentials(
1874
scheme, host, port, user, path, realm)
1878
def set_credentials(self, name, host, user, scheme=None, password=None,
1879
port=None, path=None, verify_certificates=None,
1881
"""Set authentication credentials for a host.
1883
Any existing credentials with matching scheme, host, port and path
1884
will be deleted, regardless of name.
1886
:param name: An arbitrary name to describe this set of credentials.
1887
:param host: Name of the host that accepts these credentials.
1888
:param user: The username portion of these credentials.
1889
:param scheme: The URL scheme (e.g. ssh, http) the credentials apply
1891
:param password: Password portion of these credentials.
1892
:param port: The IP port on the host that these credentials apply to.
1893
:param path: A filesystem path on the host that these credentials
1895
:param verify_certificates: On https, verify server certificates if
1897
:param realm: The http authentication realm (optional).
1899
values = {'host': host, 'user': user}
1900
if password is not None:
1901
values['password'] = password
1902
if scheme is not None:
1903
values['scheme'] = scheme
1904
if port is not None:
1905
values['port'] = '%d' % port
1906
if path is not None:
1907
values['path'] = path
1908
if verify_certificates is not None:
1909
values['verify_certificates'] = str(verify_certificates)
1910
if realm is not None:
1911
values['realm'] = realm
1912
config = self._get_config()
1914
for section, existing_values in config.items():
1915
for key in ('scheme', 'host', 'port', 'path', 'realm'):
1916
if existing_values.get(key) != values.get(key):
1920
config.update({name: values})
1923
def get_user(self, scheme, host, port=None, realm=None, path=None,
1924
prompt=None, ask=False, default=None):
1925
"""Get a user from authentication file.
1927
:param scheme: protocol
1929
:param host: the server address
1931
:param port: the associated port (optional)
1933
:param realm: the realm sent by the server (optional)
1935
:param path: the absolute path on the server (optional)
1937
:param ask: Ask the user if there is no explicitly configured username
1940
:param default: The username returned if none is defined (optional).
1942
:return: The found user.
1944
credentials = self.get_credentials(scheme, host, port, user=None,
1945
path=path, realm=realm)
1946
if credentials is not None:
1947
user = credentials['user']
1953
# Create a default prompt suitable for most cases
1954
prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1955
# Special handling for optional fields in the prompt
1956
if port is not None:
1957
prompt_host = '%s:%d' % (host, port)
1960
user = ui.ui_factory.get_username(prompt, host=prompt_host)
1965
def get_password(self, scheme, host, user, port=None,
1966
realm=None, path=None, prompt=None):
1967
"""Get a password from authentication file or prompt the user for one.
1969
:param scheme: protocol
1971
:param host: the server address
1973
:param port: the associated port (optional)
1977
:param realm: the realm sent by the server (optional)
1979
:param path: the absolute path on the server (optional)
1981
:return: The found password or the one entered by the user.
1983
credentials = self.get_credentials(scheme, host, port, user, path,
1985
if credentials is not None:
1986
password = credentials['password']
1987
if password is not None and scheme is 'ssh':
1988
trace.warning('password ignored in section [%s],'
1989
' use an ssh agent instead'
1990
% credentials['name'])
1994
# Prompt user only if we could't find a password
1995
if password is None:
1997
# Create a default prompt suitable for most cases
1998
prompt = u'%s' % scheme.upper() + u' %(user)s@%(host)s password'
1999
# Special handling for optional fields in the prompt
2000
if port is not None:
2001
prompt_host = '%s:%d' % (host, port)
2004
password = ui.ui_factory.get_password(prompt,
2005
host=prompt_host, user=user)
2008
def decode_password(self, credentials, encoding):
2010
cs = credential_store_registry.get_credential_store(encoding)
2012
raise ValueError('%r is not a known password_encoding' % encoding)
2013
credentials['password'] = cs.decode_password(credentials)
2017
class CredentialStoreRegistry(registry.Registry):
2018
"""A class that registers credential stores.
2020
A credential store provides access to credentials via the password_encoding
2021
field in authentication.conf sections.
2023
Except for stores provided by bzr itself, most stores are expected to be
2024
provided by plugins that will therefore use
2025
register_lazy(password_encoding, module_name, member_name, help=help,
2026
fallback=fallback) to install themselves.
2028
A fallback credential store is one that is queried if no credentials can be
2029
found via authentication.conf.
2032
def get_credential_store(self, encoding=None):
2033
cs = self.get(encoding)
2038
def is_fallback(self, name):
2039
"""Check if the named credentials store should be used as fallback."""
2040
return self.get_info(name)
2042
def get_fallback_credentials(self, scheme, host, port=None, user=None,
2043
path=None, realm=None):
2044
"""Request credentials from all fallback credentials stores.
2046
The first credentials store that can provide credentials wins.
2049
for name in self.keys():
2050
if not self.is_fallback(name):
2052
cs = self.get_credential_store(name)
2053
credentials = cs.get_credentials(scheme, host, port, user,
2055
if credentials is not None:
2056
# We found some credentials
2060
def register(self, key, obj, help=None, override_existing=False,
2062
"""Register a new object to a name.
2064
:param key: This is the key to use to request the object later.
2065
:param obj: The object to register.
2066
:param help: Help text for this entry. This may be a string or
2067
a callable. If it is a callable, it should take two
2068
parameters (registry, key): this registry and the key that
2069
the help was registered under.
2070
:param override_existing: Raise KeyErorr if False and something has
2071
already been registered for that key. If True, ignore if there
2072
is an existing key (always register the new value).
2073
:param fallback: Whether this credential store should be
2076
return super(CredentialStoreRegistry,
2077
self).register(key, obj, help, info=fallback,
2078
override_existing=override_existing)
2080
def register_lazy(self, key, module_name, member_name,
2081
help=None, override_existing=False,
2083
"""Register a new credential store to be loaded on request.
2085
:param module_name: The python path to the module. Such as 'os.path'.
2086
:param member_name: The member of the module to return. If empty or
2087
None, get() will return the module itself.
2088
:param help: Help text for this entry. This may be a string or
2090
:param override_existing: If True, replace the existing object
2091
with the new one. If False, if there is already something
2092
registered with the same key, raise a KeyError
2093
:param fallback: Whether this credential store should be
2096
return super(CredentialStoreRegistry, self).register_lazy(
2097
key, module_name, member_name, help,
2098
info=fallback, override_existing=override_existing)
2101
credential_store_registry = CredentialStoreRegistry()
2104
class CredentialStore(object):
2105
"""An abstract class to implement storage for credentials"""
2107
def decode_password(self, credentials):
2108
"""Returns a clear text password for the provided credentials."""
2109
raise NotImplementedError(self.decode_password)
2111
def get_credentials(self, scheme, host, port=None, user=None, path=None,
2113
"""Return the matching credentials from this credential store.
2115
This method is only called on fallback credential stores.
2117
raise NotImplementedError(self.get_credentials)
2121
class PlainTextCredentialStore(CredentialStore):
2122
__doc__ = """Plain text credential store for the authentication.conf file"""
2124
def decode_password(self, credentials):
2125
"""See CredentialStore.decode_password."""
2126
return credentials['password']
2129
credential_store_registry.register('plain', PlainTextCredentialStore,
2130
help=PlainTextCredentialStore.__doc__)
2131
credential_store_registry.default_key = 'plain'
2134
class BzrDirConfig(object):
2136
def __init__(self, bzrdir):
2137
self._bzrdir = bzrdir
2138
self._config = bzrdir._get_config()
2140
def set_default_stack_on(self, value):
2141
"""Set the default stacking location.
2143
It may be set to a location, or None.
2145
This policy affects all branches contained by this control dir, except
2146
for those under repositories.
2148
if self._config is None:
2149
raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
2151
self._config.set_option('', 'default_stack_on')
2153
self._config.set_option(value, 'default_stack_on')
2155
def get_default_stack_on(self):
2156
"""Return the default stacking location.
2158
This will either be a location, or None.
2160
This policy affects all branches contained by this control dir, except
2161
for those under repositories.
2163
if self._config is None:
2165
value = self._config.get_option('default_stack_on')
2171
class TransportConfig(object):
2172
"""A Config that reads/writes a config file on a Transport.
2174
It is a low-level object that considers config data to be name/value pairs
2175
that may be associated with a section. Assigning meaning to these values
2176
is done at higher levels like TreeConfig.
2179
def __init__(self, transport, filename):
2180
self._transport = transport
2181
self._filename = filename
2183
def get_option(self, name, section=None, default=None):
2184
"""Return the value associated with a named option.
2186
:param name: The name of the value
2187
:param section: The section the option is in (if any)
2188
:param default: The value to return if the value is not set
2189
:return: The value or default value
2191
configobj = self._get_configobj()
2193
section_obj = configobj
2196
section_obj = configobj[section]
2199
value = section_obj.get(name, default)
2200
for hook in OldConfigHooks['get']:
2201
hook(self, name, value)
2204
def set_option(self, value, name, section=None):
2205
"""Set the value associated with a named option.
2207
:param value: The value to set
2208
:param name: The name of the value to set
2209
:param section: The section the option is in (if any)
2211
configobj = self._get_configobj()
2213
configobj[name] = value
2215
configobj.setdefault(section, {})[name] = value
2216
for hook in OldConfigHooks['set']:
2217
hook(self, name, value)
2218
self._set_configobj(configobj)
2220
def remove_option(self, option_name, section_name=None):
2221
configobj = self._get_configobj()
2222
if section_name is None:
2223
del configobj[option_name]
2225
del configobj[section_name][option_name]
2226
for hook in OldConfigHooks['remove']:
2227
hook(self, option_name)
2228
self._set_configobj(configobj)
2230
def _get_config_file(self):
2232
f = StringIO(self._transport.get_bytes(self._filename))
2233
for hook in OldConfigHooks['load']:
2236
except errors.NoSuchFile:
2238
except errors.PermissionDenied, e:
2239
trace.warning("Permission denied while trying to open "
2240
"configuration file %s.", urlutils.unescape_for_display(
2241
urlutils.join(self._transport.base, self._filename), "utf-8"))
2244
def _external_url(self):
2245
return urlutils.join(self._transport.external_url(), self._filename)
2247
def _get_configobj(self):
2248
f = self._get_config_file()
2251
conf = ConfigObj(f, encoding='utf-8')
2252
except configobj.ConfigObjError, e:
2253
raise errors.ParseConfigError(e.errors, self._external_url())
2254
except UnicodeDecodeError:
2255
raise errors.ConfigContentError(self._external_url())
2260
def _set_configobj(self, configobj):
2261
out_file = StringIO()
2262
configobj.write(out_file)
2264
self._transport.put_file(self._filename, out_file)
2265
for hook in OldConfigHooks['save']:
2269
class Option(object):
2270
"""An option definition.
2272
The option *values* are stored in config files and found in sections.
2274
Here we define various properties about the option itself, its default
2275
value, how to convert it from stores, what to do when invalid values are
2276
encoutered, in which config files it can be stored.
2279
def __init__(self, name, override_from_env=None,
2280
default=None, default_from_env=None,
2281
help=None, from_unicode=None, invalid=None, unquote=True):
2282
"""Build an option definition.
2284
:param name: the name used to refer to the option.
2286
:param override_from_env: A list of environment variables which can
2287
provide override any configuration setting.
2289
:param default: the default value to use when none exist in the config
2290
stores. This is either a string that ``from_unicode`` will convert
2291
into the proper type, a callable returning a unicode string so that
2292
``from_unicode`` can be used on the return value, or a python
2293
object that can be stringified (so only the empty list is supported
2296
:param default_from_env: A list of environment variables which can
2297
provide a default value. 'default' will be used only if none of the
2298
variables specified here are set in the environment.
2300
:param help: a doc string to explain the option to the user.
2302
:param from_unicode: a callable to convert the unicode string
2303
representing the option value in a store. This is not called for
2306
:param invalid: the action to be taken when an invalid value is
2307
encountered in a store. This is called only when from_unicode is
2308
invoked to convert a string and returns None or raise ValueError or
2309
TypeError. Accepted values are: None (ignore invalid values),
2310
'warning' (emit a warning), 'error' (emit an error message and
2313
:param unquote: should the unicode value be unquoted before conversion.
2314
This should be used only when the store providing the values cannot
2315
safely unquote them (see http://pad.lv/906897). It is provided so
2316
daughter classes can handle the quoting themselves.
2318
if override_from_env is None:
2319
override_from_env = []
2320
if default_from_env is None:
2321
default_from_env = []
2323
self.override_from_env = override_from_env
2324
# Convert the default value to a unicode string so all values are
2325
# strings internally before conversion (via from_unicode) is attempted.
2328
elif isinstance(default, list):
2329
# Only the empty list is supported
2331
raise AssertionError(
2332
'Only empty lists are supported as default values')
2334
elif isinstance(default, (str, unicode, bool, int, float)):
2335
# Rely on python to convert strings, booleans and integers
2336
self.default = u'%s' % (default,)
2337
elif callable(default):
2338
self.default = default
2340
# other python objects are not expected
2341
raise AssertionError('%r is not supported as a default value'
2343
self.default_from_env = default_from_env
2345
self.from_unicode = from_unicode
2346
self.unquote = unquote
2347
if invalid and invalid not in ('warning', 'error'):
2348
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2349
self.invalid = invalid
2355
def convert_from_unicode(self, store, unicode_value):
2356
if self.unquote and store is not None and unicode_value is not None:
2357
unicode_value = store.unquote(unicode_value)
2358
if self.from_unicode is None or unicode_value is None:
2359
# Don't convert or nothing to convert
2360
return unicode_value
2362
converted = self.from_unicode(unicode_value)
2363
except (ValueError, TypeError):
2364
# Invalid values are ignored
2366
if converted is None and self.invalid is not None:
2367
# The conversion failed
2368
if self.invalid == 'warning':
2369
trace.warning('Value "%s" is not valid for "%s"',
2370
unicode_value, self.name)
2371
elif self.invalid == 'error':
2372
raise errors.ConfigOptionValueError(self.name, unicode_value)
2375
def get_override(self):
2377
for var in self.override_from_env:
2379
# If the env variable is defined, its value takes precedence
2380
value = os.environ[var].decode(osutils.get_user_encoding())
2386
def get_default(self):
2388
for var in self.default_from_env:
2390
# If the env variable is defined, its value is the default one
2391
value = os.environ[var].decode(osutils.get_user_encoding())
2396
# Otherwise, fallback to the value defined at registration
2397
if callable(self.default):
2398
value = self.default()
2399
if not isinstance(value, unicode):
2400
raise AssertionError(
2401
'Callable default values should be unicode')
2403
value = self.default
2406
def get_help_topic(self):
2409
def get_help_text(self, additional_see_also=None, plain=True):
2411
from bzrlib import help_topics
2412
result += help_topics._format_see_also(additional_see_also)
2414
result = help_topics.help_as_plain_text(result)
2418
# Predefined converters to get proper values from store
2420
def bool_from_store(unicode_str):
2421
return ui.bool_from_string(unicode_str)
2424
def int_from_store(unicode_str):
2425
return int(unicode_str)
2428
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2430
def int_SI_from_store(unicode_str):
2431
"""Convert a human readable size in SI units, e.g 10MB into an integer.
2433
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
2434
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
2437
:return Integer, expanded to its base-10 value if a proper SI unit is
2438
found, None otherwise.
2440
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2441
p = re.compile(regexp, re.IGNORECASE)
2442
m = p.match(unicode_str)
2445
val, _, unit = m.groups()
2449
coeff = _unit_suffixes[unit.upper()]
2451
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2456
def float_from_store(unicode_str):
2457
return float(unicode_str)
2460
# Use a an empty dict to initialize an empty configobj avoiding all
2461
# parsing and encoding checks
2462
_list_converter_config = configobj.ConfigObj(
2463
{}, encoding='utf-8', list_values=True, interpolation=False)
2466
class ListOption(Option):
2468
def __init__(self, name, default=None, default_from_env=None,
2469
help=None, invalid=None):
2470
"""A list Option definition.
2472
This overrides the base class so the conversion from a unicode string
2473
can take quoting into account.
2475
super(ListOption, self).__init__(
2476
name, default=default, default_from_env=default_from_env,
2477
from_unicode=self.from_unicode, help=help,
2478
invalid=invalid, unquote=False)
2480
def from_unicode(self, unicode_str):
2481
if not isinstance(unicode_str, basestring):
2483
# Now inject our string directly as unicode. All callers got their
2484
# value from configobj, so values that need to be quoted are already
2486
_list_converter_config.reset()
2487
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2488
maybe_list = _list_converter_config['list']
2489
if isinstance(maybe_list, basestring):
2491
# A single value, most probably the user forgot (or didn't care
2492
# to add) the final ','
2495
# The empty string, convert to empty list
2498
# We rely on ConfigObj providing us with a list already
2503
class RegistryOption(Option):
2504
"""Option for a choice from a registry."""
2506
def __init__(self, name, registry, default_from_env=None,
2507
help=None, invalid=None):
2508
"""A registry based Option definition.
2510
This overrides the base class so the conversion from a unicode string
2511
can take quoting into account.
2513
super(RegistryOption, self).__init__(
2514
name, default=lambda: unicode(registry.default_key),
2515
default_from_env=default_from_env,
2516
from_unicode=self.from_unicode, help=help,
2517
invalid=invalid, unquote=False)
2518
self.registry = registry
2520
def from_unicode(self, unicode_str):
2521
if not isinstance(unicode_str, basestring):
2524
return self.registry.get(unicode_str)
2527
"Invalid value %s for %s."
2528
"See help for a list of possible values." % (unicode_str,
2533
ret = [self._help, "\n\nThe following values are supported:\n"]
2534
for key in self.registry.keys():
2535
ret.append(" %s - %s\n" % (key, self.registry.get_help(key)))
2539
class OptionRegistry(registry.Registry):
2540
"""Register config options by their name.
2542
This overrides ``registry.Registry`` to simplify registration by acquiring
2543
some information from the option object itself.
2546
def register(self, option):
2547
"""Register a new option to its name.
2549
:param option: The option to register. Its name is used as the key.
2551
super(OptionRegistry, self).register(option.name, option,
2554
def register_lazy(self, key, module_name, member_name):
2555
"""Register a new option to be loaded on request.
2557
:param key: the key to request the option later. Since the registration
2558
is lazy, it should be provided and match the option name.
2560
:param module_name: the python path to the module. Such as 'os.path'.
2562
:param member_name: the member of the module to return. If empty or
2563
None, get() will return the module itself.
2565
super(OptionRegistry, self).register_lazy(key,
2566
module_name, member_name)
2568
def get_help(self, key=None):
2569
"""Get the help text associated with the given key"""
2570
option = self.get(key)
2571
the_help = option.help
2572
if callable(the_help):
2573
return the_help(self, key)
2577
option_registry = OptionRegistry()
2580
# Registered options in lexicographical order
2582
option_registry.register(
2583
Option('append_revisions_only',
2584
default=None, from_unicode=bool_from_store, invalid='warning',
2586
Whether to only append revisions to the mainline.
2588
If this is set to true, then it is not possible to change the
2589
existing mainline of the branch.
2591
option_registry.register(
2592
ListOption('acceptable_keys',
2595
List of GPG key patterns which are acceptable for verification.
2597
option_registry.register(
2598
Option('add.maximum_file_size',
2599
default=u'20MB', from_unicode=int_SI_from_store,
2601
Size above which files should be added manually.
2603
Files below this size are added automatically when using ``bzr add`` without
2606
A negative value means disable the size check.
2608
option_registry.register(
2610
default=None, from_unicode=bool_from_store,
2612
Is the branch bound to ``bound_location``.
2614
If set to "True", the branch should act as a checkout, and push each commit to
2615
the bound_location. This option is normally set by ``bind``/``unbind``.
2617
See also: bound_location.
2619
option_registry.register(
2620
Option('bound_location',
2623
The location that commits should go to when acting as a checkout.
2625
This option is normally set by ``bind``.
2629
option_registry.register(
2630
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2632
Whether revisions associated with tags should be fetched.
2634
option_registry.register_lazy(
2635
'bzr.transform.orphan_policy', 'bzrlib.transform', 'opt_transform_orphan')
2636
option_registry.register(
2637
Option('bzr.workingtree.worth_saving_limit', default=10,
2638
from_unicode=int_from_store, invalid='warning',
2640
How many changes before saving the dirstate.
2642
-1 means that we will never rewrite the dirstate file for only
2643
stat-cache changes. Regardless of this setting, we will always rewrite
2644
the dirstate file if a file is added/removed/renamed/etc. This flag only
2645
affects the behavior of updating the dirstate file after we notice that
2646
a file has been touched.
2648
option_registry.register(
2649
Option('bugtracker', default=None,
2651
Default bug tracker to use.
2653
This bug tracker will be used for example when marking bugs
2654
as fixed using ``bzr commit --fixes``, if no explicit
2655
bug tracker was specified.
2657
option_registry.register(
2658
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2659
from_unicode=signature_policy_from_unicode,
2661
GPG checking policy.
2663
Possible values: require, ignore, check-available (default)
2665
this option will control whether bzr will require good gpg
2666
signatures, ignore them, or check them if they are
2669
option_registry.register(
2670
Option('child_submit_format',
2671
help='''The preferred format of submissions to this branch.'''))
2672
option_registry.register(
2673
Option('child_submit_to',
2674
help='''Where submissions to this branch are mailed to.'''))
2675
option_registry.register(
2676
Option('create_signatures', default=SIGN_WHEN_REQUIRED,
2677
from_unicode=signing_policy_from_unicode,
2681
Possible values: always, never, when-required (default)
2683
This option controls whether bzr will always create
2684
gpg signatures or not on commits.
2686
option_registry.register(
2687
Option('dirstate.fdatasync', default=True,
2688
from_unicode=bool_from_store,
2690
Flush dirstate changes onto physical disk?
2692
If true (default), working tree metadata changes are flushed through the
2693
OS buffers to physical disk. This is somewhat slower, but means data
2694
should not be lost if the machine crashes. See also repository.fdatasync.
2696
option_registry.register(
2697
ListOption('debug_flags', default=[],
2698
help='Debug flags to activate.'))
2699
option_registry.register(
2700
Option('default_format', default='2a',
2701
help='Format used when creating branches.'))
2702
option_registry.register(
2703
Option('dpush_strict', default=None,
2704
from_unicode=bool_from_store,
2706
The default value for ``dpush --strict``.
2708
If present, defines the ``--strict`` option default value for checking
2709
uncommitted changes before pushing into a different VCS without any
2710
custom bzr metadata.
2712
option_registry.register(
2714
help='The command called to launch an editor to enter a message.'))
2715
option_registry.register(
2716
Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
2717
help='The users identity'))
2718
option_registry.register(
2719
Option('gpg_signing_command',
2722
Program to use use for creating signatures.
2724
This should support at least the -u and --clearsign options.
2726
option_registry.register(
2727
Option('gpg_signing_key',
2730
GPG key to use for signing.
2732
This defaults to the first key associated with the users email.
2734
option_registry.register(
2735
Option('ignore_missing_extensions', default=False,
2736
from_unicode=bool_from_store,
2738
Control the missing extensions warning display.
2740
The warning will not be emitted if set to True.
2742
option_registry.register(
2744
help='Language to translate messages into.'))
2745
option_registry.register(
2746
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2748
Steal locks that appears to be dead.
2750
If set to True, bzr will check if a lock is supposed to be held by an
2751
active process from the same user on the same machine. If the user and
2752
machine match, but no process with the given PID is active, then bzr
2753
will automatically break the stale lock, and create a new lock for
2755
Otherwise, bzr will prompt as normal to break the lock.
2757
option_registry.register(
2758
Option('log_format', default='long',
2760
Log format to use when displaying revisions.
2762
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2763
may be provided by plugins.
2765
option_registry.register_lazy('mail_client', 'bzrlib.mail_client',
2767
option_registry.register(
2768
Option('output_encoding',
2769
help= 'Unicode encoding for output'
2770
' (terminal encoding if not specified).'))
2771
option_registry.register(
2772
Option('parent_location',
2775
The location of the default branch for pull or merge.
2777
This option is normally set when creating a branch, the first ``pull`` or by
2778
``pull --remember``.
2780
option_registry.register(
2781
Option('post_commit', default=None,
2783
Post commit functions.
2785
An ordered list of python functions to call, separated by spaces.
2787
Each function takes branch, rev_id as parameters.
2789
option_registry.register(
2790
Option('public_branch',
2793
A publically-accessible version of this branch.
2795
This implies that the branch setting this option is not publically-accessible.
2796
Used and set by ``bzr send``.
2798
option_registry.register(
2799
Option('push_location',
2802
The location of the default branch for push.
2804
This option is normally set by the first ``push`` or ``push --remember``.
2806
option_registry.register(
2807
Option('push_strict', default=None,
2808
from_unicode=bool_from_store,
2810
The default value for ``push --strict``.
2812
If present, defines the ``--strict`` option default value for checking
2813
uncommitted changes before sending a merge directive.
2815
option_registry.register(
2816
Option('repository.fdatasync', default=True,
2817
from_unicode=bool_from_store,
2819
Flush repository changes onto physical disk?
2821
If true (default), repository changes are flushed through the OS buffers
2822
to physical disk. This is somewhat slower, but means data should not be
2823
lost if the machine crashes. See also dirstate.fdatasync.
2825
option_registry.register_lazy('smtp_server',
2826
'bzrlib.smtp_connection', 'smtp_server')
2827
option_registry.register_lazy('smtp_password',
2828
'bzrlib.smtp_connection', 'smtp_password')
2829
option_registry.register_lazy('smtp_username',
2830
'bzrlib.smtp_connection', 'smtp_username')
2831
option_registry.register(
2832
Option('selftest.timeout',
2834
from_unicode=int_from_store,
2835
help='Abort selftest if one test takes longer than this many seconds',
2838
option_registry.register(
2839
Option('send_strict', default=None,
2840
from_unicode=bool_from_store,
2842
The default value for ``send --strict``.
2844
If present, defines the ``--strict`` option default value for checking
2845
uncommitted changes before sending a bundle.
2848
option_registry.register(
2849
Option('serve.client_timeout',
2850
default=300.0, from_unicode=float_from_store,
2851
help="If we wait for a new request from a client for more than"
2852
" X seconds, consider the client idle, and hangup."))
2853
option_registry.register(
2854
Option('stacked_on_location',
2856
help="""The location where this branch is stacked on."""))
2857
option_registry.register(
2858
Option('submit_branch',
2861
The branch you intend to submit your current work to.
2863
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2864
by the ``submit:`` revision spec.
2866
option_registry.register(
2868
help='''Where submissions from this branch are mailed to.'''))
2869
option_registry.register(
2870
ListOption('suppress_warnings',
2872
help="List of warning classes to suppress."))
2873
option_registry.register(
2874
Option('validate_signatures_in_log', default=False,
2875
from_unicode=bool_from_store, invalid='warning',
2876
help='''Whether to validate signatures in bzr log.'''))
2877
option_registry.register_lazy('ssl.ca_certs',
2878
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2880
option_registry.register_lazy('ssl.cert_reqs',
2881
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2884
class Section(object):
2885
"""A section defines a dict of option name => value.
2887
This is merely a read-only dict which can add some knowledge about the
2888
options. It is *not* a python dict object though and doesn't try to mimic
2892
def __init__(self, section_id, options):
2893
self.id = section_id
2894
# We re-use the dict-like object received
2895
self.options = options
2897
def get(self, name, default=None, expand=True):
2898
return self.options.get(name, default)
2900
def iter_option_names(self):
2901
for k in self.options.iterkeys():
2905
# Mostly for debugging use
2906
return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2909
_NewlyCreatedOption = object()
2910
"""Was the option created during the MutableSection lifetime"""
2911
_DeletedOption = object()
2912
"""Was the option deleted during the MutableSection lifetime"""
2915
class MutableSection(Section):
2916
"""A section allowing changes and keeping track of the original values."""
2918
def __init__(self, section_id, options):
2919
super(MutableSection, self).__init__(section_id, options)
2920
self.reset_changes()
2922
def set(self, name, value):
2923
if name not in self.options:
2924
# This is a new option
2925
self.orig[name] = _NewlyCreatedOption
2926
elif name not in self.orig:
2927
self.orig[name] = self.get(name, None)
2928
self.options[name] = value
2930
def remove(self, name):
2931
if name not in self.orig:
2932
self.orig[name] = self.get(name, None)
2933
del self.options[name]
2935
def reset_changes(self):
2938
def apply_changes(self, dirty, store):
2939
"""Apply option value changes.
2941
``self`` has been reloaded from the persistent storage. ``dirty``
2942
contains the changes made since the previous loading.
2944
:param dirty: the mutable section containing the changes.
2946
:param store: the store containing the section
2948
for k, expected in dirty.orig.iteritems():
2949
actual = dirty.get(k, _DeletedOption)
2950
reloaded = self.get(k, _NewlyCreatedOption)
2951
if actual is _DeletedOption:
2952
if k in self.options:
2956
# Report concurrent updates in an ad-hoc way. This should only
2957
# occurs when different processes try to update the same option
2958
# which is not supported (as in: the config framework is not meant
2959
# to be used as a sharing mechanism).
2960
if expected != reloaded:
2961
if actual is _DeletedOption:
2962
actual = '<DELETED>'
2963
if reloaded is _NewlyCreatedOption:
2964
reloaded = '<CREATED>'
2965
if expected is _NewlyCreatedOption:
2966
expected = '<CREATED>'
2967
# Someone changed the value since we get it from the persistent
2969
trace.warning(gettext(
2970
"Option {0} in section {1} of {2} was changed"
2971
" from {3} to {4}. The {5} value will be saved.".format(
2972
k, self.id, store.external_url(), expected,
2974
# No need to keep track of these changes
2975
self.reset_changes()
2978
class Store(object):
2979
"""Abstract interface to persistent storage for configuration options."""
2981
readonly_section_class = Section
2982
mutable_section_class = MutableSection
2985
# Which sections need to be saved (by section id). We use a dict here
2986
# so the dirty sections can be shared by multiple callers.
2987
self.dirty_sections = {}
2989
def is_loaded(self):
2990
"""Returns True if the Store has been loaded.
2992
This is used to implement lazy loading and ensure the persistent
2993
storage is queried only when needed.
2995
raise NotImplementedError(self.is_loaded)
2998
"""Loads the Store from persistent storage."""
2999
raise NotImplementedError(self.load)
3001
def _load_from_string(self, bytes):
3002
"""Create a store from a string in configobj syntax.
3004
:param bytes: A string representing the file content.
3006
raise NotImplementedError(self._load_from_string)
3009
"""Unloads the Store.
3011
This should make is_loaded() return False. This is used when the caller
3012
knows that the persistent storage has changed or may have change since
3015
raise NotImplementedError(self.unload)
3017
def quote(self, value):
3018
"""Quote a configuration option value for storing purposes.
3020
This allows Stacks to present values as they will be stored.
3024
def unquote(self, value):
3025
"""Unquote a configuration option value into unicode.
3027
The received value is quoted as stored.
3032
"""Saves the Store to persistent storage."""
3033
raise NotImplementedError(self.save)
3035
def _need_saving(self):
3036
for s in self.dirty_sections.values():
3038
# At least one dirty section contains a modification
3042
def apply_changes(self, dirty_sections):
3043
"""Apply changes from dirty sections while checking for coherency.
3045
The Store content is discarded and reloaded from persistent storage to
3046
acquire up-to-date values.
3048
Dirty sections are MutableSection which kept track of the value they
3049
are expected to update.
3051
# We need an up-to-date version from the persistent storage, unload the
3052
# store. The reload will occur when needed (triggered by the first
3053
# get_mutable_section() call below.
3055
# Apply the changes from the preserved dirty sections
3056
for section_id, dirty in dirty_sections.iteritems():
3057
clean = self.get_mutable_section(section_id)
3058
clean.apply_changes(dirty, self)
3059
# Everything is clean now
3060
self.dirty_sections = {}
3062
def save_changes(self):
3063
"""Saves the Store to persistent storage if changes occurred.
3065
Apply the changes recorded in the mutable sections to a store content
3066
refreshed from persistent storage.
3068
raise NotImplementedError(self.save_changes)
3070
def external_url(self):
3071
raise NotImplementedError(self.external_url)
3073
def get_sections(self):
3074
"""Returns an ordered iterable of existing sections.
3076
:returns: An iterable of (store, section).
3078
raise NotImplementedError(self.get_sections)
3080
def get_mutable_section(self, section_id=None):
3081
"""Returns the specified mutable section.
3083
:param section_id: The section identifier
3085
raise NotImplementedError(self.get_mutable_section)
3088
# Mostly for debugging use
3089
return "<config.%s(%s)>" % (self.__class__.__name__,
3090
self.external_url())
3093
class CommandLineStore(Store):
3094
"A store to carry command line overrides for the config options."""
3096
def __init__(self, opts=None):
3097
super(CommandLineStore, self).__init__()
3104
# The dict should be cleared but not replaced so it can be shared.
3105
self.options.clear()
3107
def _from_cmdline(self, overrides):
3108
# Reset before accepting new definitions
3110
for over in overrides:
3112
name, value = over.split('=', 1)
3114
raise errors.BzrCommandError(
3115
gettext("Invalid '%s', should be of the form 'name=value'")
3117
self.options[name] = value
3119
def external_url(self):
3120
# Not an url but it makes debugging easier and is never needed
3124
def get_sections(self):
3125
yield self, self.readonly_section_class(None, self.options)
3128
class IniFileStore(Store):
3129
"""A config Store using ConfigObj for storage.
3131
:ivar _config_obj: Private member to hold the ConfigObj instance used to
3132
serialize/deserialize the config file.
3136
"""A config Store using ConfigObj for storage.
3138
super(IniFileStore, self).__init__()
3139
self._config_obj = None
3141
def is_loaded(self):
3142
return self._config_obj != None
3145
self._config_obj = None
3146
self.dirty_sections = {}
3148
def _load_content(self):
3149
"""Load the config file bytes.
3151
This should be provided by subclasses
3153
:return: Byte string
3155
raise NotImplementedError(self._load_content)
3157
def _save_content(self, content):
3158
"""Save the config file bytes.
3160
This should be provided by subclasses
3162
:param content: Config file bytes to write
3164
raise NotImplementedError(self._save_content)
3167
"""Load the store from the associated file."""
3168
if self.is_loaded():
3170
content = self._load_content()
3171
self._load_from_string(content)
3172
for hook in ConfigHooks['load']:
3175
def _load_from_string(self, bytes):
3176
"""Create a config store from a string.
3178
:param bytes: A string representing the file content.
3180
if self.is_loaded():
3181
raise AssertionError('Already loaded: %r' % (self._config_obj,))
3182
co_input = StringIO(bytes)
3184
# The config files are always stored utf8-encoded
3185
self._config_obj = ConfigObj(co_input, encoding='utf-8',
3187
except configobj.ConfigObjError, e:
3188
self._config_obj = None
3189
raise errors.ParseConfigError(e.errors, self.external_url())
3190
except UnicodeDecodeError:
3191
raise errors.ConfigContentError(self.external_url())
3193
def save_changes(self):
3194
if not self.is_loaded():
3197
if not self._need_saving():
3199
# Preserve the current version
3200
dirty_sections = dict(self.dirty_sections.items())
3201
self.apply_changes(dirty_sections)
3202
# Save to the persistent storage
3206
if not self.is_loaded():
3210
self._config_obj.write(out)
3211
self._save_content(out.getvalue())
3212
for hook in ConfigHooks['save']:
3215
def get_sections(self):
3216
"""Get the configobj section in the file order.
3218
:returns: An iterable of (store, section).
3220
# We need a loaded store
3223
except (errors.NoSuchFile, errors.PermissionDenied):
3224
# If the file can't be read, there is no sections
3226
cobj = self._config_obj
3228
yield self, self.readonly_section_class(None, cobj)
3229
for section_name in cobj.sections:
3231
self.readonly_section_class(section_name,
3232
cobj[section_name]))
3234
def get_mutable_section(self, section_id=None):
3235
# We need a loaded store
3238
except errors.NoSuchFile:
3239
# The file doesn't exist, let's pretend it was empty
3240
self._load_from_string('')
3241
if section_id in self.dirty_sections:
3242
# We already created a mutable section for this id
3243
return self.dirty_sections[section_id]
3244
if section_id is None:
3245
section = self._config_obj
3247
section = self._config_obj.setdefault(section_id, {})
3248
mutable_section = self.mutable_section_class(section_id, section)
3249
# All mutable sections can become dirty
3250
self.dirty_sections[section_id] = mutable_section
3251
return mutable_section
3253
def quote(self, value):
3255
# configobj conflates automagical list values and quoting
3256
self._config_obj.list_values = True
3257
return self._config_obj._quote(value)
3259
self._config_obj.list_values = False
3261
def unquote(self, value):
3262
if value and isinstance(value, basestring):
3263
# _unquote doesn't handle None nor empty strings nor anything that
3264
# is not a string, really.
3265
value = self._config_obj._unquote(value)
3268
def external_url(self):
3269
# Since an IniFileStore can be used without a file (at least in tests),
3270
# it's better to provide something than raising a NotImplementedError.
3271
# All daughter classes are supposed to provide an implementation
3273
return 'In-Process Store, no URL'
3275
class TransportIniFileStore(IniFileStore):
3276
"""IniFileStore that loads files from a transport.
3278
:ivar transport: The transport object where the config file is located.
3280
:ivar file_name: The config file basename in the transport directory.
3283
def __init__(self, transport, file_name):
3284
"""A Store using a ini file on a Transport
3286
:param transport: The transport object where the config file is located.
3287
:param file_name: The config file basename in the transport directory.
3289
super(TransportIniFileStore, self).__init__()
3290
self.transport = transport
3291
self.file_name = file_name
3293
def _load_content(self):
3295
return self.transport.get_bytes(self.file_name)
3296
except errors.PermissionDenied:
3297
trace.warning("Permission denied while trying to load "
3298
"configuration store %s.", self.external_url())
3301
def _save_content(self, content):
3302
self.transport.put_bytes(self.file_name, content)
3304
def external_url(self):
3305
# FIXME: external_url should really accepts an optional relpath
3306
# parameter (bug #750169) :-/ -- vila 2011-04-04
3307
# The following will do in the interim but maybe we don't want to
3308
# expose a path here but rather a config ID and its associated
3309
# object </hand wawe>.
3310
return urlutils.join(self.transport.external_url(), self.file_name)
3313
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3314
# unlockable stores for use with objects that can already ensure the locking
3315
# (think branches). If different stores (not based on ConfigObj) are created,
3316
# they may face the same issue.
3319
class LockableIniFileStore(TransportIniFileStore):
3320
"""A ConfigObjStore using locks on save to ensure store integrity."""
3322
def __init__(self, transport, file_name, lock_dir_name=None):
3323
"""A config Store using ConfigObj for storage.
3325
:param transport: The transport object where the config file is located.
3327
:param file_name: The config file basename in the transport directory.
3329
if lock_dir_name is None:
3330
lock_dir_name = 'lock'
3331
self.lock_dir_name = lock_dir_name
3332
super(LockableIniFileStore, self).__init__(transport, file_name)
3333
self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
3335
def lock_write(self, token=None):
3336
"""Takes a write lock in the directory containing the config file.
3338
If the directory doesn't exist it is created.
3340
# FIXME: This doesn't check the ownership of the created directories as
3341
# ensure_config_dir_exists does. It should if the transport is local
3342
# -- vila 2011-04-06
3343
self.transport.create_prefix()
3344
return self._lock.lock_write(token)
3349
def break_lock(self):
3350
self._lock.break_lock()
3354
# We need to be able to override the undecorated implementation
3355
self.save_without_locking()
3357
def save_without_locking(self):
3358
super(LockableIniFileStore, self).save()
3361
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
3362
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
3363
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
3365
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
3366
# functions or a registry will make it easier and clearer for tests, focusing
3367
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3368
# on a poolie's remark)
3369
class GlobalStore(LockableIniFileStore):
3371
def __init__(self, possible_transports=None):
3372
t = transport.get_transport_from_path(
3373
config_dir(), possible_transports=possible_transports)
3374
super(GlobalStore, self).__init__(t, 'bazaar.conf')
3378
class LocationStore(LockableIniFileStore):
3380
def __init__(self, possible_transports=None):
3381
t = transport.get_transport_from_path(
3382
config_dir(), possible_transports=possible_transports)
3383
super(LocationStore, self).__init__(t, 'locations.conf')
3384
self.id = 'locations'
3387
class BranchStore(TransportIniFileStore):
3389
def __init__(self, branch):
3390
super(BranchStore, self).__init__(branch.control_transport,
3392
self.branch = branch
3396
class ControlStore(LockableIniFileStore):
3398
def __init__(self, bzrdir):
3399
super(ControlStore, self).__init__(bzrdir.transport,
3401
lock_dir_name='branch_lock')
3405
class SectionMatcher(object):
3406
"""Select sections into a given Store.
3408
This is intended to be used to postpone getting an iterable of sections
3412
def __init__(self, store):
3415
def get_sections(self):
3416
# This is where we require loading the store so we can see all defined
3418
sections = self.store.get_sections()
3419
# Walk the revisions in the order provided
3420
for store, s in sections:
3424
def match(self, section):
3425
"""Does the proposed section match.
3427
:param section: A Section object.
3429
:returns: True if the section matches, False otherwise.
3431
raise NotImplementedError(self.match)
3434
class NameMatcher(SectionMatcher):
3436
def __init__(self, store, section_id):
3437
super(NameMatcher, self).__init__(store)
3438
self.section_id = section_id
3440
def match(self, section):
3441
return section.id == self.section_id
3444
class LocationSection(Section):
3446
def __init__(self, section, extra_path):
3447
super(LocationSection, self).__init__(section.id, section.options)
3448
self.extra_path = extra_path
3449
self.locals = {'relpath': extra_path,
3450
'basename': urlutils.basename(extra_path)}
3452
def get(self, name, default=None, expand=True):
3453
value = super(LocationSection, self).get(name, default)
3454
if value is not None and expand:
3455
policy_name = self.get(name + ':policy', None)
3456
policy = _policy_value.get(policy_name, POLICY_NONE)
3457
if policy == POLICY_APPENDPATH:
3458
value = urlutils.join(value, self.extra_path)
3459
# expand section local options right now (since POLICY_APPENDPATH
3460
# will never add options references, it's ok to expand after it).
3462
for is_ref, chunk in iter_option_refs(value):
3464
chunks.append(chunk)
3467
if ref in self.locals:
3468
chunks.append(self.locals[ref])
3470
chunks.append(chunk)
3471
value = ''.join(chunks)
3475
class StartingPathMatcher(SectionMatcher):
3476
"""Select sections for a given location respecting the Store order."""
3478
# FIXME: Both local paths and urls can be used for section names as well as
3479
# ``location`` to stay consistent with ``LocationMatcher`` which itself
3480
# inherited the fuzziness from the previous ``LocationConfig``
3481
# implementation. We probably need to revisit which encoding is allowed for
3482
# both ``location`` and section names and how we normalize
3483
# them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
3484
# related too. -- vila 2012-01-04
3486
def __init__(self, store, location):
3487
super(StartingPathMatcher, self).__init__(store)
3488
if location.startswith('file://'):
3489
location = urlutils.local_path_from_url(location)
3490
self.location = location
3492
def get_sections(self):
3493
"""Get all sections matching ``location`` in the store.
3495
The most generic sections are described first in the store, then more
3496
specific ones can be provided for reduced scopes.
3498
The returned section are therefore returned in the reversed order so
3499
the most specific ones can be found first.
3501
location_parts = self.location.rstrip('/').split('/')
3504
# Later sections are more specific, they should be returned first
3505
for _, section in reversed(list(store.get_sections())):
3506
if section.id is None:
3507
# The no-name section is always included if present
3508
yield store, LocationSection(section, self.location)
3510
section_path = section.id
3511
if section_path.startswith('file://'):
3512
# the location is already a local path or URL, convert the
3513
# section id to the same format
3514
section_path = urlutils.local_path_from_url(section_path)
3515
if (self.location.startswith(section_path)
3516
or fnmatch.fnmatch(self.location, section_path)):
3517
section_parts = section_path.rstrip('/').split('/')
3518
extra_path = '/'.join(location_parts[len(section_parts):])
3519
yield store, LocationSection(section, extra_path)
3522
class LocationMatcher(SectionMatcher):
3524
def __init__(self, store, location):
3525
super(LocationMatcher, self).__init__(store)
3526
if location.startswith('file://'):
3527
location = urlutils.local_path_from_url(location)
3528
self.location = location
3530
def _get_matching_sections(self):
3531
"""Get all sections matching ``location``."""
3532
# We slightly diverge from LocalConfig here by allowing the no-name
3533
# section as the most generic one and the lower priority.
3534
no_name_section = None
3536
# Filter out the no_name_section so _iter_for_location_by_parts can be
3537
# used (it assumes all sections have a name).
3538
for _, section in self.store.get_sections():
3539
if section.id is None:
3540
no_name_section = section
3542
all_sections.append(section)
3543
# Unfortunately _iter_for_location_by_parts deals with section names so
3544
# we have to resync.
3545
filtered_sections = _iter_for_location_by_parts(
3546
[s.id for s in all_sections], self.location)
3547
iter_all_sections = iter(all_sections)
3548
matching_sections = []
3549
if no_name_section is not None:
3550
matching_sections.append(
3551
(0, LocationSection(no_name_section, self.location)))
3552
for section_id, extra_path, length in filtered_sections:
3553
# a section id is unique for a given store so it's safe to take the
3554
# first matching section while iterating. Also, all filtered
3555
# sections are part of 'all_sections' and will always be found
3558
section = iter_all_sections.next()
3559
if section_id == section.id:
3560
matching_sections.append(
3561
(length, LocationSection(section, extra_path)))
3563
return matching_sections
3565
def get_sections(self):
3566
# Override the default implementation as we want to change the order
3567
matching_sections = self._get_matching_sections()
3568
# We want the longest (aka more specific) locations first
3569
sections = sorted(matching_sections,
3570
key=lambda (length, section): (length, section.id),
3572
# Sections mentioning 'ignore_parents' restrict the selection
3573
for _, section in sections:
3574
# FIXME: We really want to use as_bool below -- vila 2011-04-07
3575
ignore = section.get('ignore_parents', None)
3576
if ignore is not None:
3577
ignore = ui.bool_from_string(ignore)
3580
# Finally, we have a valid section
3581
yield self.store, section
3584
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
3585
"""Describes an expandable option reference.
3587
We want to match the most embedded reference first.
3589
I.e. for '{{foo}}' we will get '{foo}',
3590
for '{bar{baz}}' we will get '{baz}'
3593
def iter_option_refs(string):
3594
# Split isolate refs so every other chunk is a ref
3596
for chunk in _option_ref_re.split(string):
3601
class Stack(object):
3602
"""A stack of configurations where an option can be defined"""
3604
def __init__(self, sections_def, store=None, mutable_section_id=None):
3605
"""Creates a stack of sections with an optional store for changes.
3607
:param sections_def: A list of Section or callables that returns an
3608
iterable of Section. This defines the Sections for the Stack and
3609
can be called repeatedly if needed.
3611
:param store: The optional Store where modifications will be
3612
recorded. If none is specified, no modifications can be done.
3614
:param mutable_section_id: The id of the MutableSection where changes
3615
are recorded. This requires the ``store`` parameter to be
3618
self.sections_def = sections_def
3620
self.mutable_section_id = mutable_section_id
3622
def iter_sections(self):
3623
"""Iterate all the defined sections."""
3624
# Ensuring lazy loading is achieved by delaying section matching (which
3625
# implies querying the persistent storage) until it can't be avoided
3626
# anymore by using callables to describe (possibly empty) section
3628
for sections in self.sections_def:
3629
for store, section in sections():
3630
yield store, section
3632
def get(self, name, expand=True, convert=True):
3633
"""Return the *first* option value found in the sections.
3635
This is where we guarantee that sections coming from Store are loaded
3636
lazily: the loading is delayed until we need to either check that an
3637
option exists or get its value, which in turn may require to discover
3638
in which sections it can be defined. Both of these (section and option
3639
existence) require loading the store (even partially).
3641
:param name: The queried option.
3643
:param expand: Whether options references should be expanded.
3645
:param convert: Whether the option value should be converted from
3646
unicode (do nothing for non-registered options).
3648
:returns: The value of the option.
3650
# FIXME: No caching of options nor sections yet -- vila 20110503
3652
found_store = None # Where the option value has been found
3653
# If the option is registered, it may provide additional info about
3656
opt = option_registry.get(name)
3661
def expand_and_convert(val):
3662
# This may need to be called in different contexts if the value is
3663
# None or ends up being None during expansion or conversion.
3666
if isinstance(val, basestring):
3667
val = self._expand_options_in_string(val)
3669
trace.warning('Cannot expand "%s":'
3670
' %s does not support option expansion'
3671
% (name, type(val)))
3673
val = found_store.unquote(val)
3675
val = opt.convert_from_unicode(found_store, val)
3678
# First of all, check if the environment can override the configuration
3680
if opt is not None and opt.override_from_env:
3681
value = opt.get_override()
3682
value = expand_and_convert(value)
3684
for store, section in self.iter_sections():
3685
value = section.get(name)
3686
if value is not None:
3689
value = expand_and_convert(value)
3690
if opt is not None and value is None:
3691
# If the option is registered, it may provide a default value
3692
value = opt.get_default()
3693
value = expand_and_convert(value)
3694
for hook in ConfigHooks['get']:
3695
hook(self, name, value)
3698
def expand_options(self, string, env=None):
3699
"""Expand option references in the string in the configuration context.
3701
:param string: The string containing option(s) to expand.
3703
:param env: An option dict defining additional configuration options or
3704
overriding existing ones.
3706
:returns: The expanded string.
3708
return self._expand_options_in_string(string, env)
3710
def _expand_options_in_string(self, string, env=None, _refs=None):
3711
"""Expand options in the string in the configuration context.
3713
:param string: The string to be expanded.
3715
:param env: An option dict defining additional configuration options or
3716
overriding existing ones.
3718
:param _refs: Private list (FIFO) containing the options being expanded
3721
:returns: The expanded string.
3724
# Not much to expand there
3727
# What references are currently resolved (to detect loops)
3730
# We need to iterate until no more refs appear ({{foo}} will need two
3731
# iterations for example).
3736
for is_ref, chunk in iter_option_refs(result):
3738
chunks.append(chunk)
3743
raise errors.OptionExpansionLoop(string, _refs)
3745
value = self._expand_option(name, env, _refs)
3747
raise errors.ExpandingUnknownOption(name, string)
3748
chunks.append(value)
3750
result = ''.join(chunks)
3753
def _expand_option(self, name, env, _refs):
3754
if env is not None and name in env:
3755
# Special case, values provided in env takes precedence over
3759
value = self.get(name, expand=False, convert=False)
3760
value = self._expand_options_in_string(value, env, _refs)
3763
def _get_mutable_section(self):
3764
"""Get the MutableSection for the Stack.
3766
This is where we guarantee that the mutable section is lazily loaded:
3767
this means we won't load the corresponding store before setting a value
3768
or deleting an option. In practice the store will often be loaded but
3769
this helps catching some programming errors.
3772
section = store.get_mutable_section(self.mutable_section_id)
3773
return store, section
3775
def set(self, name, value):
3776
"""Set a new value for the option."""
3777
store, section = self._get_mutable_section()
3778
section.set(name, store.quote(value))
3779
for hook in ConfigHooks['set']:
3780
hook(self, name, value)
3782
def remove(self, name):
3783
"""Remove an existing option."""
3784
_, section = self._get_mutable_section()
3785
section.remove(name)
3786
for hook in ConfigHooks['remove']:
3790
# Mostly for debugging use
3791
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3793
def _get_overrides(self):
3794
# Hack around library_state.initialize never called
3795
if bzrlib.global_state is not None:
3796
return bzrlib.global_state.cmdline_overrides.get_sections()
3800
class MemoryStack(Stack):
3801
"""A configuration stack defined from a string.
3803
This is mainly intended for tests and requires no disk resources.
3806
def __init__(self, content=None):
3807
"""Create an in-memory stack from a given content.
3809
It uses a single store based on configobj and support reading and
3812
:param content: The initial content of the store. If None, the store is
3813
not loaded and ``_load_from_string`` can and should be used if
3816
store = IniFileStore()
3817
if content is not None:
3818
store._load_from_string(content)
3819
super(MemoryStack, self).__init__(
3820
[store.get_sections], store)
3823
class _CompatibleStack(Stack):
3824
"""Place holder for compatibility with previous design.
3826
This is intended to ease the transition from the Config-based design to the
3827
Stack-based design and should not be used nor relied upon by plugins.
3829
One assumption made here is that the daughter classes will all use Stores
3830
derived from LockableIniFileStore).
3832
It implements set() and remove () by re-loading the store before applying
3833
the modification and saving it.
3835
The long term plan being to implement a single write by store to save
3836
all modifications, this class should not be used in the interim.
3839
def set(self, name, value):
3842
super(_CompatibleStack, self).set(name, value)
3843
# Force a write to persistent storage
3846
def remove(self, name):
3849
super(_CompatibleStack, self).remove(name)
3850
# Force a write to persistent storage
3854
class GlobalStack(_CompatibleStack):
3855
"""Global options only stack.
3857
The following sections are queried:
3859
* command-line overrides,
3861
* the 'DEFAULT' section in bazaar.conf
3863
This stack will use the ``DEFAULT`` section in bazaar.conf as its
3868
gstore = GlobalStore()
3869
super(GlobalStack, self).__init__(
3870
[self._get_overrides,
3871
NameMatcher(gstore, 'DEFAULT').get_sections],
3872
gstore, mutable_section_id='DEFAULT')
3875
class LocationStack(_CompatibleStack):
3876
"""Per-location options falling back to global options stack.
3879
The following sections are queried:
3881
* command-line overrides,
3883
* the sections matching ``location`` in ``locations.conf``, the order being
3884
defined by the number of path components in the section glob, higher
3885
numbers first (from most specific section to most generic).
3887
* the 'DEFAULT' section in bazaar.conf
3889
This stack will use the ``location`` section in locations.conf as its
3893
def __init__(self, location):
3894
"""Make a new stack for a location and global configuration.
3896
:param location: A URL prefix to """
3897
lstore = LocationStore()
3898
if location.startswith('file://'):
3899
location = urlutils.local_path_from_url(location)
3900
gstore = GlobalStore()
3901
super(LocationStack, self).__init__(
3902
[self._get_overrides,
3903
LocationMatcher(lstore, location).get_sections,
3904
NameMatcher(gstore, 'DEFAULT').get_sections],
3905
lstore, mutable_section_id=location)
3908
class BranchStack(Stack):
3909
"""Per-location options falling back to branch then global options stack.
3911
The following sections are queried:
3913
* command-line overrides,
3915
* the sections matching ``location`` in ``locations.conf``, the order being
3916
defined by the number of path components in the section glob, higher
3917
numbers first (from most specific section to most generic),
3919
* the no-name section in branch.conf,
3921
* the ``DEFAULT`` section in ``bazaar.conf``.
3923
This stack will use the no-name section in ``branch.conf`` as its
3927
def __init__(self, branch):
3928
lstore = LocationStore()
3929
bstore = branch._get_config_store()
3930
gstore = GlobalStore()
3931
super(BranchStack, self).__init__(
3932
[self._get_overrides,
3933
LocationMatcher(lstore, branch.base).get_sections,
3934
NameMatcher(bstore, None).get_sections,
3935
NameMatcher(gstore, 'DEFAULT').get_sections],
3937
self.branch = branch
3939
def lock_write(self, token=None):
3940
return self.branch.lock_write(token)
3943
return self.branch.unlock()
3946
def set(self, name, value):
3947
super(BranchStack, self).set(name, value)
3948
# Unlocking the branch will trigger a store.save_changes() so the last
3949
# unlock saves all the changes.
3952
def remove(self, name):
3953
super(BranchStack, self).remove(name)
3954
# Unlocking the branch will trigger a store.save_changes() so the last
3955
# unlock saves all the changes.
3958
class RemoteControlStack(_CompatibleStack):
3959
"""Remote control-only options stack."""
3961
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3962
# with the stack used for remote bzr dirs. RemoteControlStack only uses
3963
# control.conf and is used only for stack options.
3965
def __init__(self, bzrdir):
3966
cstore = bzrdir._get_config_store()
3967
super(RemoteControlStack, self).__init__(
3968
[NameMatcher(cstore, None).get_sections],
3970
self.bzrdir = bzrdir
3973
class BranchOnlyStack(Stack):
3974
"""Branch-only options stack."""
3976
# FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
3977
# stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
3978
# -- vila 2011-12-16
3980
def __init__(self, branch):
3981
bstore = branch._get_config_store()
3982
super(BranchOnlyStack, self).__init__(
3983
[NameMatcher(bstore, None).get_sections],
3985
self.branch = branch
3987
def lock_write(self, token=None):
3988
return self.branch.lock_write(token)
3991
return self.branch.unlock()
3994
def set(self, name, value):
3995
super(BranchOnlyStack, self).set(name, value)
3996
# Force a write to persistent storage
3997
self.store.save_changes()
4000
def remove(self, name):
4001
super(BranchOnlyStack, self).remove(name)
4002
# Force a write to persistent storage
4003
self.store.save_changes()
4006
class cmd_config(commands.Command):
4007
__doc__ = """Display, set or remove a configuration option.
4009
Display the active value for a given option.
4011
If --all is specified, NAME is interpreted as a regular expression and all
4012
matching options are displayed mentioning their scope. The active value
4013
that bzr will take into account is the first one displayed for each option.
4015
If no NAME is given, --all .* is implied.
4017
Setting a value is achieved by using name=value without spaces. The value
4018
is set in the most relevant scope and can be checked by displaying the
4022
takes_args = ['name?']
4026
# FIXME: This should be a registry option so that plugins can register
4027
# their own config files (or not) and will also address
4028
# http://pad.lv/788991 -- vila 20101115
4029
commands.Option('scope', help='Reduce the scope to the specified'
4030
' configuration file.',
4032
commands.Option('all',
4033
help='Display all the defined values for the matching options.',
4035
commands.Option('remove', help='Remove the option from'
4036
' the configuration file.'),
4039
_see_also = ['configuration']
4041
@commands.display_command
4042
def run(self, name=None, all=False, directory=None, scope=None,
4044
if directory is None:
4046
directory = urlutils.normalize_url(directory)
4048
raise errors.BzrError(
4049
'--all and --remove are mutually exclusive.')
4051
# Delete the option in the given scope
4052
self._remove_config_option(name, directory, scope)
4054
# Defaults to all options
4055
self._show_matching_options('.*', directory, scope)
4058
name, value = name.split('=', 1)
4060
# Display the option(s) value(s)
4062
self._show_matching_options(name, directory, scope)
4064
self._show_value(name, directory, scope)
4067
raise errors.BzrError(
4068
'Only one option can be set.')
4069
# Set the option value
4070
self._set_config_option(name, value, directory, scope)
4072
def _get_stack(self, directory, scope=None, write_access=False):
4073
"""Get the configuration stack specified by ``directory`` and ``scope``.
4075
:param directory: Where the configurations are derived from.
4077
:param scope: A specific config to start from.
4079
:param write_access: Whether a write access to the stack will be
4082
# FIXME: scope should allow access to plugin-specific stacks (even
4083
# reduced to the plugin-specific store), related to
4084
# http://pad.lv/788991 -- vila 2011-11-15
4085
if scope is not None:
4086
if scope == 'bazaar':
4087
return GlobalStack()
4088
elif scope == 'locations':
4089
return LocationStack(directory)
4090
elif scope == 'branch':
4092
controldir.ControlDir.open_containing_tree_or_branch(
4095
self.add_cleanup(br.lock_write().unlock)
4096
return br.get_config_stack()
4097
raise errors.NoSuchConfig(scope)
4101
controldir.ControlDir.open_containing_tree_or_branch(
4104
self.add_cleanup(br.lock_write().unlock)
4105
return br.get_config_stack()
4106
except errors.NotBranchError:
4107
return LocationStack(directory)
4109
def _quote_multiline(self, value):
4111
value = '"""' + value + '"""'
4114
def _show_value(self, name, directory, scope):
4115
conf = self._get_stack(directory, scope)
4116
value = conf.get(name, expand=True, convert=False)
4117
if value is not None:
4118
# Quote the value appropriately
4119
value = self._quote_multiline(value)
4120
self.outf.write('%s\n' % (value,))
4122
raise errors.NoSuchConfigOption(name)
4124
def _show_matching_options(self, name, directory, scope):
4125
name = lazy_regex.lazy_compile(name)
4126
# We want any error in the regexp to be raised *now* so we need to
4127
# avoid the delay introduced by the lazy regexp. But, we still do
4128
# want the nicer errors raised by lazy_regex.
4129
name._compile_and_collapse()
4132
conf = self._get_stack(directory, scope)
4133
for store, section in conf.iter_sections():
4134
for oname in section.iter_option_names():
4135
if name.search(oname):
4136
if cur_store_id != store.id:
4137
# Explain where the options are defined
4138
self.outf.write('%s:\n' % (store.id,))
4139
cur_store_id = store.id
4141
if (section.id is not None and cur_section != section.id):
4142
# Display the section id as it appears in the store
4143
# (None doesn't appear by definition)
4144
self.outf.write(' [%s]\n' % (section.id,))
4145
cur_section = section.id
4146
value = section.get(oname, expand=False)
4147
# Quote the value appropriately
4148
value = self._quote_multiline(value)
4149
self.outf.write(' %s = %s\n' % (oname, value))
4151
def _set_config_option(self, name, value, directory, scope):
4152
conf = self._get_stack(directory, scope, write_access=True)
4153
conf.set(name, value)
4155
def _remove_config_option(self, name, directory, scope):
4157
raise errors.BzrCommandError(
4158
'--remove expects an option to remove.')
4159
conf = self._get_stack(directory, scope, write_access=True)
4163
raise errors.NoSuchConfigOption(name)
4168
# We need adapters that can build a Store or a Stack in a test context. Test
4169
# classes, based on TestCaseWithTransport, can use the registry to parametrize
4170
# themselves. The builder will receive a test instance and should return a
4171
# ready-to-use store or stack. Plugins that define new store/stacks can also
4172
# register themselves here to be tested against the tests defined in
4173
# bzrlib.tests.test_config. Note that the builder can be called multiple times
4174
# for the same test.
4176
# The registered object should be a callable receiving a test instance
4177
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
4179
test_store_builder_registry = registry.Registry()
4181
# The registered object should be a callable receiving a test instance
4182
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
4184
test_stack_builder_registry = registry.Registry()
392
m = re.search(r'[\w+.-]+@[\w+.-]+', e)
394
raise BzrError("%r doesn't seem to contain "
395
"a reasonable email address" % e)
added
removed
bzrlib/config.py
