← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

(gz) Cleanup and test selftest thread leak detection (Martin [gz])

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
65
65
import os
66
66
import sys
67
67
 
68
 
from bzrlib import commands
69
68
from bzrlib.decorators import needs_write_lock
70
69
from bzrlib.lazy_import import lazy_import
71
70
lazy_import(globals(), """
72
71
import errno
73
 
import fnmatch
 
72
from fnmatch import fnmatch
74
73
import re
75
74
from cStringIO import StringIO
76
75
 
77
76
import bzrlib
78
77
from bzrlib import (
79
78
    atomicfile,
80
 
    bzrdir,
81
79
    debug,
82
80
    errors,
83
81
    lockdir,
155
153
    def __init__(self):
156
154
        super(Config, self).__init__()
157
155
 
158
 
    def config_id(self):
159
 
        """Returns a unique ID for the config."""
160
 
        raise NotImplementedError(self.config_id)
161
 
 
162
156
    def get_editor(self):
163
157
        """Get the users pop up editor."""
164
158
        raise NotImplementedError
450
444
        """Override this to define the section used by the config."""
451
445
        return "DEFAULT"
452
446
 
453
 
    def _get_sections(self, name=None):
454
 
        """Returns an iterator of the sections specified by ``name``.
455
 
 
456
 
        :param name: The section name. If None is supplied, the default
457
 
            configurations are yielded.
458
 
 
459
 
        :return: A tuple (name, section, config_id) for all sections that will
460
 
            be walked by user_get_option() in the 'right' order. The first one
461
 
            is where set_user_option() will update the value.
462
 
        """
463
 
        parser = self._get_parser()
464
 
        if name is not None:
465
 
            yield (name, parser[name], self.config_id())
466
 
        else:
467
 
            # No section name has been given so we fallback to the configobj
468
 
            # itself which holds the variables defined outside of any section.
469
 
            yield (None, parser, self.config_id())
470
 
 
471
 
    def _get_options(self, sections=None):
472
 
        """Return an ordered list of (name, value, section, config_id) tuples.
473
 
 
474
 
        All options are returned with their associated value and the section
475
 
        they appeared in. ``config_id`` is a unique identifier for the
476
 
        configuration file the option is defined in.
477
 
 
478
 
        :param sections: Default to ``_get_matching_sections`` if not
479
 
            specified. This gives a better control to daughter classes about
480
 
            which sections should be searched. This is a list of (name,
481
 
            configobj) tuples.
482
 
        """
483
 
        opts = []
484
 
        if sections is None:
485
 
            parser = self._get_parser()
486
 
            sections = []
487
 
            for (section_name, _) in self._get_matching_sections():
488
 
                try:
489
 
                    section = parser[section_name]
490
 
                except KeyError:
491
 
                    # This could happen for an empty file for which we define a
492
 
                    # DEFAULT section. FIXME: Force callers to provide sections
493
 
                    # instead ? -- vila 20100930
494
 
                    continue
495
 
                sections.append((section_name, section))
496
 
        config_id = self.config_id()
497
 
        for (section_name, section) in sections:
498
 
            for (name, value) in section.iteritems():
499
 
                yield (name, parser._quote(value), section_name,
500
 
                       config_id, parser)
501
 
 
502
447
    def _get_option_policy(self, section, option_name):
503
448
        """Return the policy for the given (section, option_name) pair."""
504
449
        return POLICY_NONE
591
536
    def _get_nickname(self):
592
537
        return self.get_user_option('nickname')
593
538
 
594
 
    def remove_user_option(self, option_name, section_name=None):
595
 
        """Remove a user option and save the configuration file.
596
 
 
597
 
        :param option_name: The option to be removed.
598
 
 
599
 
        :param section_name: The section the option is defined in, default to
600
 
            the default section.
601
 
        """
602
 
        self.reload()
603
 
        parser = self._get_parser()
604
 
        if section_name is None:
605
 
            section = parser
606
 
        else:
607
 
            section = parser[section_name]
608
 
        try:
609
 
            del section[option_name]
610
 
        except KeyError:
611
 
            raise errors.NoSuchConfigOption(option_name)
612
 
        self._write_config_file()
613
 
 
614
539
    def _write_config_file(self):
615
540
        if self.file_name is None:
616
541
            raise AssertionError('We cannot save, self.file_name is None')
679
604
    def break_lock(self):
680
605
        self._lock.break_lock()
681
606
 
682
 
    @needs_write_lock
683
 
    def remove_user_option(self, option_name, section_name=None):
684
 
        super(LockableConfig, self).remove_user_option(option_name,
685
 
                                                       section_name)
686
 
 
687
607
    def _write_config_file(self):
688
608
        if self._lock is None or not self._lock.is_held:
689
609
            # NB: if the following exception is raised it probably means a
698
618
    def __init__(self):
699
619
        super(GlobalConfig, self).__init__(file_name=config_filename())
700
620
 
701
 
    def config_id(self):
702
 
        return 'bazaar'
703
 
 
704
621
    @classmethod
705
622
    def from_string(cls, str_or_unicode, save=False):
706
623
        """Create a config object from a string.
750
667
        self._write_config_file()
751
668
 
752
669
 
753
 
    def _get_sections(self, name=None):
754
 
        """See IniBasedConfig._get_sections()."""
755
 
        parser = self._get_parser()
756
 
        # We don't give access to options defined outside of any section, we
757
 
        # used the DEFAULT section by... default.
758
 
        if name in (None, 'DEFAULT'):
759
 
            # This could happen for an empty file where the DEFAULT section
760
 
            # doesn't exist yet. So we force DEFAULT when yielding
761
 
            name = 'DEFAULT'
762
 
            if 'DEFAULT' not in parser:
763
 
               parser['DEFAULT']= {}
764
 
        yield (name, parser[name], self.config_id())
765
 
 
766
 
    @needs_write_lock
767
 
    def remove_user_option(self, option_name, section_name=None):
768
 
        if section_name is None:
769
 
            # We need to force the default section.
770
 
            section_name = 'DEFAULT'
771
 
        # We need to avoid the LockableConfig implementation or we'll lock
772
 
        # twice
773
 
        super(LockableConfig, self).remove_user_option(option_name,
774
 
                                                       section_name)
775
 
 
776
 
 
777
670
class LocationConfig(LockableConfig):
778
671
    """A configuration object that gives the policy for a location."""
779
672
 
787
680
            location = urlutils.local_path_from_url(location)
788
681
        self.location = location
789
682
 
790
 
    def config_id(self):
791
 
        return 'locations'
792
 
 
793
683
    @classmethod
794
684
    def from_string(cls, str_or_unicode, location, save=False):
795
685
        """Create a config object from a string.
827
717
            names = zip(location_names, section_names)
828
718
            matched = True
829
719
            for name in names:
830
 
                if not fnmatch.fnmatch(name[0], name[1]):
 
720
                if not fnmatch(name[0], name[1]):
831
721
                    matched = False
832
722
                    break
833
723
            if not matched:
838
728
                continue
839
729
            matches.append((len(section_names), section,
840
730
                            '/'.join(location_names[len(section_names):])))
841
 
        # put the longest (aka more specific) locations first
842
731
        matches.sort(reverse=True)
843
732
        sections = []
844
733
        for (length, section, extra_path) in matches:
851
740
                pass
852
741
        return sections
853
742
 
854
 
    def _get_sections(self, name=None):
855
 
        """See IniBasedConfig._get_sections()."""
856
 
        # We ignore the name here as the only sections handled are named with
857
 
        # the location path and we don't expose embedded sections either.
858
 
        parser = self._get_parser()
859
 
        for name, extra_path in self._get_matching_sections():
860
 
            yield (name, parser[name], self.config_id())
861
 
 
862
743
    def _get_option_policy(self, section, option_name):
863
744
        """Return the policy for the given (section, option_name) pair."""
864
745
        # check for the old 'recurse=False' flag
943
824
                               self._get_branch_data_config,
944
825
                               self._get_global_config)
945
826
 
946
 
    def config_id(self):
947
 
        return 'branch'
948
 
 
949
827
    def _get_branch_data_config(self):
950
828
        if self._branch_data_config is None:
951
829
            self._branch_data_config = TreeConfig(self.branch)
952
 
            self._branch_data_config.config_id = self.config_id
953
830
        return self._branch_data_config
954
831
 
955
832
    def _get_location_config(self):
1023
900
                return value
1024
901
        return None
1025
902
 
1026
 
    def _get_sections(self, name=None):
1027
 
        """See IniBasedConfig.get_sections()."""
1028
 
        for source in self.option_sources:
1029
 
            for section in source()._get_sections(name):
1030
 
                yield section
1031
 
 
1032
 
    def _get_options(self, sections=None):
1033
 
        opts = []
1034
 
        # First the locations options
1035
 
        for option in self._get_location_config()._get_options():
1036
 
            yield option
1037
 
        # Then the branch options
1038
 
        branch_config = self._get_branch_data_config()
1039
 
        if sections is None:
1040
 
            sections = [('DEFAULT', branch_config._get_parser())]
1041
 
        # FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1042
 
        # Config itself has no notion of sections :( -- vila 20101001
1043
 
        config_id = self.config_id()
1044
 
        for (section_name, section) in sections:
1045
 
            for (name, value) in section.iteritems():
1046
 
                yield (name, value, section_name,
1047
 
                       config_id, branch_config._get_parser())
1048
 
        # Then the global options
1049
 
        for option in self._get_global_config()._get_options():
1050
 
            yield option
1051
 
 
1052
903
    def set_user_option(self, name, value, store=STORE_BRANCH,
1053
904
        warn_masked=False):
1054
905
        if store == STORE_BRANCH:
1072
923
                        trace.warning('Value "%s" is masked by "%s" from'
1073
924
                                      ' branch.conf', value, mask_value)
1074
925
 
1075
 
    def remove_user_option(self, option_name, section_name=None):
1076
 
        self._get_branch_data_config().remove_option(option_name, section_name)
1077
 
 
1078
926
    def _gpg_signing_command(self):
1079
927
        """See Config.gpg_signing_command."""
1080
928
        return self._get_safe_value('_gpg_signing_command')
1114
962
            parent_dir = os.path.dirname(path)
1115
963
            if not os.path.isdir(parent_dir):
1116
964
                trace.mutter('creating config parent directory: %r', parent_dir)
1117
 
                os.mkdir(parent_dir)
 
965
            os.mkdir(parent_dir)
1118
966
        trace.mutter('creating config directory: %r', path)
1119
967
        os.mkdir(path)
1120
968
        osutils.copy_ownership_from_path(path)
1123
971
def config_dir():
1124
972
    """Return per-user configuration directory.
1125
973
 
1126
 
    By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1127
 
    and Linux.  On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1128
 
    that will be used instead.
 
974
    By default this is ~/.bazaar/
1129
975
 
1130
976
    TODO: Global option --config-dir to override this.
1131
977
    """
1139
985
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
1140
986
                                  ' or HOME set')
1141
987
        return osutils.pathjoin(base, 'bazaar', '2.0')
1142
 
    elif sys.platform == 'darwin':
1143
 
        if base is None:
1144
 
            # this takes into account $HOME
1145
 
            base = os.path.expanduser("~")
1146
 
        return osutils.pathjoin(base, '.bazaar')
1147
988
    else:
1148
989
        if base is None:
1149
 
 
1150
 
            xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1151
 
            if xdg_dir is None:
1152
 
                xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1153
 
            xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1154
 
            if osutils.isdir(xdg_dir):
1155
 
                trace.mutter(
1156
 
                    "Using configuration in XDG directory %s." % xdg_dir)
1157
 
                return xdg_dir
1158
 
 
1159
990
            base = os.path.expanduser("~")
1160
991
        return osutils.pathjoin(base, ".bazaar")
1161
992
 
1255
1086
 
1256
1087
    def set_option(self, value, name, section=None):
1257
1088
        """Set a per-branch configuration option"""
1258
 
        # FIXME: We shouldn't need to lock explicitly here but rather rely on
1259
 
        # higher levels providing the right lock -- vila 20101004
1260
1089
        self.branch.lock_write()
1261
1090
        try:
1262
1091
            self._config.set_option(value, name, section)
1263
1092
        finally:
1264
1093
            self.branch.unlock()
1265
1094
 
1266
 
    def remove_option(self, option_name, section_name=None):
1267
 
        # FIXME: We shouldn't need to lock explicitly here but rather rely on
1268
 
        # higher levels providing the right lock -- vila 20101004
1269
 
        self.branch.lock_write()
1270
 
        try:
1271
 
            self._config.remove_option(option_name, section_name)
1272
 
        finally:
1273
 
            self.branch.unlock()
1274
 
 
1275
1095
 
1276
1096
class AuthenticationConfig(object):
1277
1097
    """The authentication configuration file based on a ini file.
1720
1540
    """A Config that reads/writes a config file on a Transport.
1721
1541
 
1722
1542
    It is a low-level object that considers config data to be name/value pairs
1723
 
    that may be associated with a section.  Assigning meaning to these values
1724
 
    is done at higher levels like TreeConfig.
 
1543
    that may be associated with a section.  Assigning meaning to the these
 
1544
    values is done at higher levels like TreeConfig.
1725
1545
    """
1726
1546
 
1727
1547
    def __init__(self, transport, filename):
1760
1580
            configobj.setdefault(section, {})[name] = value
1761
1581
        self._set_configobj(configobj)
1762
1582
 
1763
 
    def remove_option(self, option_name, section_name=None):
1764
 
        configobj = self._get_configobj()
1765
 
        if section_name is None:
1766
 
            del configobj[option_name]
1767
 
        else:
1768
 
            del configobj[section_name][option_name]
1769
 
        self._set_configobj(configobj)
1770
 
 
1771
1583
    def _get_config_file(self):
1772
1584
        try:
1773
1585
            return StringIO(self._transport.get_bytes(self._filename))
1786
1598
        configobj.write(out_file)
1787
1599
        out_file.seek(0)
1788
1600
        self._transport.put_file(self._filename, out_file)
1789
 
 
1790
 
 
1791
 
class cmd_config(commands.Command):
1792
 
    __doc__ = """Display, set or remove a configuration option.
1793
 
 
1794
 
    Display the active value for a given option.
1795
 
 
1796
 
    If --all is specified, NAME is interpreted as a regular expression and all
1797
 
    matching options are displayed mentioning their scope. The active value
1798
 
    that bzr will take into account is the first one displayed for each option.
1799
 
 
1800
 
    If no NAME is given, --all .* is implied.
1801
 
 
1802
 
    Setting a value is achieved by using name=value without spaces. The value
1803
 
    is set in the most relevant scope and can be checked by displaying the
1804
 
    option again.
1805
 
    """
1806
 
 
1807
 
    takes_args = ['name?']
1808
 
 
1809
 
    takes_options = [
1810
 
        'directory',
1811
 
        # FIXME: This should be a registry option so that plugins can register
1812
 
        # their own config files (or not) -- vila 20101002
1813
 
        commands.Option('scope', help='Reduce the scope to the specified'
1814
 
                        ' configuration file',
1815
 
                        type=unicode),
1816
 
        commands.Option('all',
1817
 
            help='Display all the defined values for the matching options.',
1818
 
            ),
1819
 
        commands.Option('remove', help='Remove the option from'
1820
 
                        ' the configuration file'),
1821
 
        ]
1822
 
 
1823
 
    @commands.display_command
1824
 
    def run(self, name=None, all=False, directory=None, scope=None,
1825
 
            remove=False):
1826
 
        if directory is None:
1827
 
            directory = '.'
1828
 
        directory = urlutils.normalize_url(directory)
1829
 
        if remove and all:
1830
 
            raise errors.BzrError(
1831
 
                '--all and --remove are mutually exclusive.')
1832
 
        elif remove:
1833
 
            # Delete the option in the given scope
1834
 
            self._remove_config_option(name, directory, scope)
1835
 
        elif name is None:
1836
 
            # Defaults to all options
1837
 
            self._show_matching_options('.*', directory, scope)
1838
 
        else:
1839
 
            try:
1840
 
                name, value = name.split('=', 1)
1841
 
            except ValueError:
1842
 
                # Display the option(s) value(s)
1843
 
                if all:
1844
 
                    self._show_matching_options(name, directory, scope)
1845
 
                else:
1846
 
                    self._show_value(name, directory, scope)
1847
 
            else:
1848
 
                if all:
1849
 
                    raise errors.BzrError(
1850
 
                        'Only one option can be set.')
1851
 
                # Set the option value
1852
 
                self._set_config_option(name, value, directory, scope)
1853
 
 
1854
 
    def _get_configs(self, directory, scope=None):
1855
 
        """Iterate the configurations specified by ``directory`` and ``scope``.
1856
 
 
1857
 
        :param directory: Where the configurations are derived from.
1858
 
 
1859
 
        :param scope: A specific config to start from.
1860
 
        """
1861
 
        if scope is not None:
1862
 
            if scope == 'bazaar':
1863
 
                yield GlobalConfig()
1864
 
            elif scope == 'locations':
1865
 
                yield LocationConfig(directory)
1866
 
            elif scope == 'branch':
1867
 
                (_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1868
 
                    directory)
1869
 
                yield br.get_config()
1870
 
        else:
1871
 
            try:
1872
 
                (_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
1873
 
                    directory)
1874
 
                yield br.get_config()
1875
 
            except errors.NotBranchError:
1876
 
                yield LocationConfig(directory)
1877
 
                yield GlobalConfig()
1878
 
 
1879
 
    def _show_value(self, name, directory, scope):
1880
 
        displayed = False
1881
 
        for c in self._get_configs(directory, scope):
1882
 
            if displayed:
1883
 
                break
1884
 
            for (oname, value, section, conf_id, parser) in c._get_options():
1885
 
                if name == oname:
1886
 
                    # Display only the first value and exit
1887
 
 
1888
 
                    # FIXME: We need to use get_user_option to take policies
1889
 
                    # into account and we need to make sure the option exists
1890
 
                    # too (hence the two for loops), this needs a better API
1891
 
                    # -- vila 20101117
1892
 
                    value = c.get_user_option(name)
1893
 
                    # Quote the value appropriately
1894
 
                    value = parser._quote(value)
1895
 
                    self.outf.write('%s\n' % (value,))
1896
 
                    displayed = True
1897
 
                    break
1898
 
        if not displayed:
1899
 
            raise errors.NoSuchConfigOption(name)
1900
 
 
1901
 
    def _show_matching_options(self, name, directory, scope):
1902
 
        name = re.compile(name)
1903
 
        # We want any error in the regexp to be raised *now* so we need to
1904
 
        # avoid the delay introduced by the lazy regexp.
1905
 
        name._compile_and_collapse()
1906
 
        cur_conf_id = None
1907
 
        cur_section = None
1908
 
        for c in self._get_configs(directory, scope):
1909
 
            for (oname, value, section, conf_id, parser) in c._get_options():
1910
 
                if name.search(oname):
1911
 
                    if cur_conf_id != conf_id:
1912
 
                        # Explain where the options are defined
1913
 
                        self.outf.write('%s:\n' % (conf_id,))
1914
 
                        cur_conf_id = conf_id
1915
 
                        cur_section = None
1916
 
                    if (section not in (None, 'DEFAULT')
1917
 
                        and cur_section != section):
1918
 
                        # Display the section if it's not the default (or only)
1919
 
                        # one.
1920
 
                        self.outf.write('  [%s]\n' % (section,))
1921
 
                        cur_section = section
1922
 
                    self.outf.write('  %s = %s\n' % (oname, value))
1923
 
 
1924
 
    def _set_config_option(self, name, value, directory, scope):
1925
 
        for conf in self._get_configs(directory, scope):
1926
 
            conf.set_user_option(name, value)
1927
 
            break
1928
 
        else:
1929
 
            raise errors.NoSuchConfig(scope)
1930
 
 
1931
 
    def _remove_config_option(self, name, directory, scope):
1932
 
        if name is None:
1933
 
            raise errors.BzrCommandError(
1934
 
                '--remove expects an option to remove.')
1935
 
        removed = False
1936
 
        for conf in self._get_configs(directory, scope):
1937
 
            for (section_name, section, conf_id) in conf._get_sections():
1938
 
                if scope is not None and conf_id != scope:
1939
 
                    # Not the right configuration file
1940
 
                    continue
1941
 
                if name in section:
1942
 
                    if conf_id != conf.config_id():
1943
 
                        conf = self._get_configs(directory, conf_id).next()
1944
 
                    # We use the first section in the first config where the
1945
 
                    # option is defined to remove it
1946
 
                    conf.remove_user_option(name, section_name)
1947
 
                    removed = True
1948
 
                    break
1949
 
            break
1950
 
        else:
1951
 
            raise errors.NoSuchConfig(scope)
1952
 
        if not removed:
1953
 
            raise errors.NoSuchConfigOption(name)