← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

Merge bzr.dev to resolve news conflict

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
68
69
from bzrlib.decorators import needs_write_lock
69
70
from bzrlib.lazy_import import lazy_import
70
71
lazy_import(globals(), """
71
72
import errno
72
 
from fnmatch import fnmatch
 
73
import fnmatch
73
74
import re
74
75
from cStringIO import StringIO
75
76
 
76
77
import bzrlib
77
78
from bzrlib import (
78
79
    atomicfile,
 
80
    bzrdir,
79
81
    debug,
80
82
    errors,
81
83
    lockdir,
153
155
    def __init__(self):
154
156
        super(Config, self).__init__()
155
157
 
 
158
    def config_id(self):
 
159
        """Returns a unique ID for the config."""
 
160
        raise NotImplementedError(self.config_id)
 
161
 
156
162
    def get_editor(self):
157
163
        """Get the users pop up editor."""
158
164
        raise NotImplementedError
444
450
        """Override this to define the section used by the config."""
445
451
        return "DEFAULT"
446
452
 
 
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
 
447
502
    def _get_option_policy(self, section, option_name):
448
503
        """Return the policy for the given (section, option_name) pair."""
449
504
        return POLICY_NONE
536
591
    def _get_nickname(self):
537
592
        return self.get_user_option('nickname')
538
593
 
 
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
 
539
614
    def _write_config_file(self):
540
615
        if self.file_name is None:
541
616
            raise AssertionError('We cannot save, self.file_name is None')
604
679
    def break_lock(self):
605
680
        self._lock.break_lock()
606
681
 
 
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
 
607
687
    def _write_config_file(self):
608
688
        if self._lock is None or not self._lock.is_held:
609
689
            # NB: if the following exception is raised it probably means a
618
698
    def __init__(self):
619
699
        super(GlobalConfig, self).__init__(file_name=config_filename())
620
700
 
 
701
    def config_id(self):
 
702
        return 'bazaar'
 
703
 
621
704
    @classmethod
622
705
    def from_string(cls, str_or_unicode, save=False):
623
706
        """Create a config object from a string.
667
750
        self._write_config_file()
668
751
 
669
752
 
 
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
 
670
777
class LocationConfig(LockableConfig):
671
778
    """A configuration object that gives the policy for a location."""
672
779
 
680
787
            location = urlutils.local_path_from_url(location)
681
788
        self.location = location
682
789
 
 
790
    def config_id(self):
 
791
        return 'locations'
 
792
 
683
793
    @classmethod
684
794
    def from_string(cls, str_or_unicode, location, save=False):
685
795
        """Create a config object from a string.
717
827
            names = zip(location_names, section_names)
718
828
            matched = True
719
829
            for name in names:
720
 
                if not fnmatch(name[0], name[1]):
 
830
                if not fnmatch.fnmatch(name[0], name[1]):
721
831
                    matched = False
722
832
                    break
723
833
            if not matched:
728
838
                continue
729
839
            matches.append((len(section_names), section,
730
840
                            '/'.join(location_names[len(section_names):])))
 
841
        # put the longest (aka more specific) locations first
731
842
        matches.sort(reverse=True)
732
843
        sections = []
733
844
        for (length, section, extra_path) in matches:
740
851
                pass
741
852
        return sections
742
853
 
 
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
 
743
862
    def _get_option_policy(self, section, option_name):
744
863
        """Return the policy for the given (section, option_name) pair."""
745
864
        # check for the old 'recurse=False' flag
824
943
                               self._get_branch_data_config,
825
944
                               self._get_global_config)
826
945
 
 
946
    def config_id(self):
 
947
        return 'branch'
 
948
 
827
949
    def _get_branch_data_config(self):
828
950
        if self._branch_data_config is None:
829
951
            self._branch_data_config = TreeConfig(self.branch)
 
952
            self._branch_data_config.config_id = self.config_id
830
953
        return self._branch_data_config
831
954
 
832
955
    def _get_location_config(self):
900
1023
                return value
901
1024
        return None
902
1025
 
 
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
 
903
1052
    def set_user_option(self, name, value, store=STORE_BRANCH,
904
1053
        warn_masked=False):
905
1054
        if store == STORE_BRANCH:
923
1072
                        trace.warning('Value "%s" is masked by "%s" from'
924
1073
                                      ' branch.conf', value, mask_value)
925
1074
 
 
1075
    def remove_user_option(self, option_name, section_name=None):
 
1076
        self._get_branch_data_config().remove_option(option_name, section_name)
 
1077
 
926
1078
    def _gpg_signing_command(self):
927
1079
        """See Config.gpg_signing_command."""
928
1080
        return self._get_safe_value('_gpg_signing_command')
962
1114
            parent_dir = os.path.dirname(path)
963
1115
            if not os.path.isdir(parent_dir):
964
1116
                trace.mutter('creating config parent directory: %r', parent_dir)
965
 
            os.mkdir(parent_dir)
 
1117
                os.mkdir(parent_dir)
966
1118
        trace.mutter('creating config directory: %r', path)
967
1119
        os.mkdir(path)
968
1120
        osutils.copy_ownership_from_path(path)
1086
1238
 
1087
1239
    def set_option(self, value, name, section=None):
1088
1240
        """Set a per-branch configuration option"""
 
1241
        # FIXME: We shouldn't need to lock explicitly here but rather rely on
 
1242
        # higher levels providing the right lock -- vila 20101004
1089
1243
        self.branch.lock_write()
1090
1244
        try:
1091
1245
            self._config.set_option(value, name, section)
1092
1246
        finally:
1093
1247
            self.branch.unlock()
1094
1248
 
 
1249
    def remove_option(self, option_name, section_name=None):
 
1250
        # FIXME: We shouldn't need to lock explicitly here but rather rely on
 
1251
        # higher levels providing the right lock -- vila 20101004
 
1252
        self.branch.lock_write()
 
1253
        try:
 
1254
            self._config.remove_option(option_name, section_name)
 
1255
        finally:
 
1256
            self.branch.unlock()
 
1257
 
1095
1258
 
1096
1259
class AuthenticationConfig(object):
1097
1260
    """The authentication configuration file based on a ini file.
1540
1703
    """A Config that reads/writes a config file on a Transport.
1541
1704
 
1542
1705
    It is a low-level object that considers config data to be name/value pairs
1543
 
    that may be associated with a section.  Assigning meaning to the these
1544
 
    values is done at higher levels like TreeConfig.
 
1706
    that may be associated with a section.  Assigning meaning to these values
 
1707
    is done at higher levels like TreeConfig.
1545
1708
    """
1546
1709
 
1547
1710
    def __init__(self, transport, filename):
1580
1743
            configobj.setdefault(section, {})[name] = value
1581
1744
        self._set_configobj(configobj)
1582
1745
 
 
1746
    def remove_option(self, option_name, section_name=None):
 
1747
        configobj = self._get_configobj()
 
1748
        if section_name is None:
 
1749
            del configobj[option_name]
 
1750
        else:
 
1751
            del configobj[section_name][option_name]
 
1752
        self._set_configobj(configobj)
 
1753
 
1583
1754
    def _get_config_file(self):
1584
1755
        try:
1585
1756
            return StringIO(self._transport.get_bytes(self._filename))
1598
1769
        configobj.write(out_file)
1599
1770
        out_file.seek(0)
1600
1771
        self._transport.put_file(self._filename, out_file)
 
1772
 
 
1773
 
 
1774
class cmd_config(commands.Command):
 
1775
    __doc__ = """Display, set or remove a configuration option.
 
1776
 
 
1777
    Display the active value for a given option.
 
1778
 
 
1779
    If --all is specified, NAME is interpreted as a regular expression and all
 
1780
    matching options are displayed mentioning their scope. The active value
 
1781
    that bzr will take into account is the first one displayed for each option.
 
1782
 
 
1783
    If no NAME is given, --all .* is implied.
 
1784
 
 
1785
    Setting a value is achieved by using name=value without spaces. The value
 
1786
    is set in the most relevant scope and can be checked by displaying the
 
1787
    option again.
 
1788
    """
 
1789
 
 
1790
    takes_args = ['name?']
 
1791
 
 
1792
    takes_options = [
 
1793
        'directory',
 
1794
        # FIXME: This should be a registry option so that plugins can register
 
1795
        # their own config files (or not) -- vila 20101002
 
1796
        commands.Option('scope', help='Reduce the scope to the specified'
 
1797
                        ' configuration file',
 
1798
                        type=unicode),
 
1799
        commands.Option('all',
 
1800
            help='Display all the defined values for the matching options.',
 
1801
            ),
 
1802
        commands.Option('remove', help='Remove the option from'
 
1803
                        ' the configuration file'),
 
1804
        ]
 
1805
 
 
1806
    @commands.display_command
 
1807
    def run(self, name=None, all=False, directory=None, scope=None,
 
1808
            remove=False):
 
1809
        if directory is None:
 
1810
            directory = '.'
 
1811
        directory = urlutils.normalize_url(directory)
 
1812
        if remove and all:
 
1813
            raise errors.BzrError(
 
1814
                '--all and --remove are mutually exclusive.')
 
1815
        elif remove:
 
1816
            # Delete the option in the given scope
 
1817
            self._remove_config_option(name, directory, scope)
 
1818
        elif name is None:
 
1819
            # Defaults to all options
 
1820
            self._show_matching_options('.*', directory, scope)
 
1821
        else:
 
1822
            try:
 
1823
                name, value = name.split('=', 1)
 
1824
            except ValueError:
 
1825
                # Display the option(s) value(s)
 
1826
                if all:
 
1827
                    self._show_matching_options(name, directory, scope)
 
1828
                else:
 
1829
                    self._show_value(name, directory, scope)
 
1830
            else:
 
1831
                if all:
 
1832
                    raise errors.BzrError(
 
1833
                        'Only one option can be set.')
 
1834
                # Set the option value
 
1835
                self._set_config_option(name, value, directory, scope)
 
1836
 
 
1837
    def _get_configs(self, directory, scope=None):
 
1838
        """Iterate the configurations specified by ``directory`` and ``scope``.
 
1839
 
 
1840
        :param directory: Where the configurations are derived from.
 
1841
 
 
1842
        :param scope: A specific config to start from.
 
1843
        """
 
1844
        if scope is not None:
 
1845
            if scope == 'bazaar':
 
1846
                yield GlobalConfig()
 
1847
            elif scope == 'locations':
 
1848
                yield LocationConfig(directory)
 
1849
            elif scope == 'branch':
 
1850
                (_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
 
1851
                    directory)
 
1852
                yield br.get_config()
 
1853
        else:
 
1854
            try:
 
1855
                (_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
 
1856
                    directory)
 
1857
                yield br.get_config()
 
1858
            except errors.NotBranchError:
 
1859
                yield LocationConfig(directory)
 
1860
                yield GlobalConfig()
 
1861
 
 
1862
    def _show_value(self, name, directory, scope):
 
1863
        displayed = False
 
1864
        for c in self._get_configs(directory, scope):
 
1865
            if displayed:
 
1866
                break
 
1867
            for (oname, value, section, conf_id, parser) in c._get_options():
 
1868
                if name == oname:
 
1869
                    # Display only the first value and exit
 
1870
 
 
1871
                    # FIXME: We need to use get_user_option to take policies
 
1872
                    # into account and we need to make sure the option exists
 
1873
                    # too (hence the two for loops), this needs a better API
 
1874
                    # -- vila 20101117
 
1875
                    value = c.get_user_option(name)
 
1876
                    # Quote the value appropriately
 
1877
                    value = parser._quote(value)
 
1878
                    self.outf.write('%s\n' % (value,))
 
1879
                    displayed = True
 
1880
                    break
 
1881
        if not displayed:
 
1882
            raise errors.NoSuchConfigOption(name)
 
1883
 
 
1884
    def _show_matching_options(self, name, directory, scope):
 
1885
        name = re.compile(name)
 
1886
        # We want any error in the regexp to be raised *now* so we need to
 
1887
        # avoid the delay introduced by the lazy regexp.
 
1888
        name._compile_and_collapse()
 
1889
        cur_conf_id = None
 
1890
        cur_section = None
 
1891
        for c in self._get_configs(directory, scope):
 
1892
            for (oname, value, section, conf_id, parser) in c._get_options():
 
1893
                if name.search(oname):
 
1894
                    if cur_conf_id != conf_id:
 
1895
                        # Explain where the options are defined
 
1896
                        self.outf.write('%s:\n' % (conf_id,))
 
1897
                        cur_conf_id = conf_id
 
1898
                        cur_section = None
 
1899
                    if (section not in (None, 'DEFAULT')
 
1900
                        and cur_section != section):
 
1901
                        # Display the section if it's not the default (or only)
 
1902
                        # one.
 
1903
                        self.outf.write('  [%s]\n' % (section,))
 
1904
                        cur_section = section
 
1905
                    self.outf.write('  %s = %s\n' % (oname, value))
 
1906
 
 
1907
    def _set_config_option(self, name, value, directory, scope):
 
1908
        for conf in self._get_configs(directory, scope):
 
1909
            conf.set_user_option(name, value)
 
1910
            break
 
1911
        else:
 
1912
            raise errors.NoSuchConfig(scope)
 
1913
 
 
1914
    def _remove_config_option(self, name, directory, scope):
 
1915
        if name is None:
 
1916
            raise errors.BzrCommandError(
 
1917
                '--remove expects an option to remove.')
 
1918
        removed = False
 
1919
        for conf in self._get_configs(directory, scope):
 
1920
            for (section_name, section, conf_id) in conf._get_sections():
 
1921
                if scope is not None and conf_id != scope:
 
1922
                    # Not the right configuration file
 
1923
                    continue
 
1924
                if name in section:
 
1925
                    if conf_id != conf.config_id():
 
1926
                        conf = self._get_configs(directory, conf_id).next()
 
1927
                    # We use the first section in the first config where the
 
1928
                    # option is defined to remove it
 
1929
                    conf.remove_user_option(name, section_name)
 
1930
                    removed = True
 
1931
                    break
 
1932
            break
 
1933
        else:
 
1934
            raise errors.NoSuchConfig(scope)
 
1935
        if not removed:
 
1936
            raise errors.NoSuchConfigOption(name)