1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
# Copyright 2010 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
__all__ = (
'features_set',
)
import logging
from portage.const import SUPPORTED_FEATURES
from portage.localization import _
from portage.output import colorize
from portage.util import writemsg_level
class features_set(object):
"""
Provides relevant set operations needed for access and modification of
config.features. The FEATURES variable is automatically synchronized
upon modification.
Modifications result in a permanent override that will cause the change
to propagate to the incremental stacking mechanism in config.regenerate().
This eliminates the need to call config.backup_changes() when FEATURES
is modified, since any overrides are guaranteed to persist despite calls
to config.reset().
"""
def __init__(self, settings):
self._settings = settings
self._features = set()
def __contains__(self, k):
return k in self._features
def __iter__(self):
return iter(self._features)
def _sync_env_var(self):
self._settings['FEATURES'] = ' '.join(sorted(self._features))
def add(self, k):
self._settings.modifying()
self._settings._features_overrides.append(k)
if k not in self._features:
self._features.add(k)
self._sync_env_var()
def update(self, values):
self._settings.modifying()
values = list(values)
self._settings._features_overrides.extend(values)
need_sync = False
for k in values:
if k in self._features:
continue
self._features.add(k)
need_sync = True
if need_sync:
self._sync_env_var()
def difference_update(self, values):
self._settings.modifying()
values = list(values)
self._settings._features_overrides.extend('-' + k for k in values)
remove_us = self._features.intersection(values)
if remove_us:
self._features.difference_update(values)
self._sync_env_var()
def remove(self, k):
"""
This never raises KeyError, since it records a permanent override
that will prevent the given flag from ever being added again by
incremental stacking in config.regenerate().
"""
self.discard(k)
def discard(self, k):
self._settings.modifying()
self._settings._features_overrides.append('-' + k)
if k in self._features:
self._features.remove(k)
self._sync_env_var()
def _validate(self):
"""
Implements unknown-features-warn and unknown-features-filter.
"""
if 'unknown-features-warn' in self._features:
unknown_features = \
self._features.difference(SUPPORTED_FEATURES)
if unknown_features:
unknown_features = unknown_features.difference(
self._settings._unknown_features)
if unknown_features:
self._settings._unknown_features.update(unknown_features)
writemsg_level(colorize("BAD",
_("FEATURES variable contains unknown value(s): %s") % \
", ".join(sorted(unknown_features))) \
+ "\n", level=logging.WARNING, noiselevel=-1)
if 'unknown-features-filter' in self._features:
unknown_features = \
self._features.difference(SUPPORTED_FEATURES)
if unknown_features:
self.difference_update(unknown_features)
self._prune_overrides()
def _prune_overrides(self):
"""
If there are lots of invalid package.env FEATURES settings
then unknown-features-filter can make _features_overrides
grow larger and larger, so prune it. This performs incremental
stacking with preservation of negative values since they need
to persist for future config.regenerate() calls.
"""
overrides_set = set(self._settings._features_overrides)
positive = set()
negative = set()
for x in self._settings._features_overrides:
if x[:1] == '-':
positive.discard(x[1:])
negative.add(x[1:])
else:
positive.add(x)
negative.discard(x)
self._settings._features_overrides[:] = \
list(positive) + list('-' + x for x in negative)
|
