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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
#!/usr/bin/env python
#
# Copyright (C) 2018 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Verify that one set of hidden API flags is a subset of another."""
import argparse
import csv
import sys
from itertools import chain
from signature_trie import signature_trie
def dict_reader(csvfile):
return csv.DictReader(
csvfile, delimiter=",", quotechar="|", fieldnames=["signature"])
def read_flag_trie_from_file(file):
with open(file, "r") as stream:
return read_flag_trie_from_stream(stream)
def read_flag_trie_from_stream(stream):
trie = signature_trie()
reader = dict_reader(stream)
for row in reader:
signature = row["signature"]
trie.add(signature, row)
return trie
def extract_subset_from_monolithic_flags_as_dict_from_file(
monolithicTrie, patternsFile):
"""Extract a subset of flags from the dict of monolithic flags.
:param monolithicFlagsDict: the dict containing all the monolithic flags.
:param patternsFile: a file containing a list of signature patterns that
define the subset.
:return: the dict from signature to row.
"""
with open(patternsFile, "r") as stream:
return extract_subset_from_monolithic_flags_as_dict_from_stream(
monolithicTrie, stream)
def extract_subset_from_monolithic_flags_as_dict_from_stream(
monolithicTrie, stream):
"""Extract a subset of flags from the trie of monolithic flags.
:param monolithicTrie: the trie containing all the monolithic flags.
:param stream: a stream containing a list of signature patterns that define
the subset.
:return: the dict from signature to row.
"""
dict_signature_to_row = {}
for pattern in stream:
pattern = pattern.rstrip()
rows = monolithicTrie.get_matching_rows(pattern)
for row in rows:
signature = row["signature"]
dict_signature_to_row[signature] = row
return dict_signature_to_row
def read_signature_csv_from_stream_as_dict(stream):
"""Read the csv contents from the stream into a dict.
The first column is assumed to be the signature and used as the
key.
The whole row is stored as the value.
:param stream: the csv contents to read
:return: the dict from signature to row.
"""
dict_signature_to_row = {}
reader = dict_reader(stream)
for row in reader:
signature = row["signature"]
dict_signature_to_row[signature] = row
return dict_signature_to_row
def read_signature_csv_from_file_as_dict(csvFile):
"""Read the csvFile into a dict.
The first column is assumed to be the signature and used as the
key.
The whole row is stored as the value.
:param csvFile: the csv file to read
:return: the dict from signature to row.
"""
with open(csvFile, "r") as f:
return read_signature_csv_from_stream_as_dict(f)
def compare_signature_flags(monolithicFlagsDict, modularFlagsDict):
"""Compare the signature flags between the two dicts.
:param monolithicFlagsDict: the dict containing the subset of the monolithic
flags that should be equal to the modular flags.
:param modularFlagsDict:the dict containing the flags produced by a single
bootclasspath_fragment module.
:return: list of mismatches., each mismatch is a tuple where the first item
is the signature, and the second and third items are lists of the flags from
modular dict, and monolithic dict respectively.
"""
mismatchingSignatures = []
# Create a sorted set of all the signatures from both the monolithic and
# modular dicts.
allSignatures = sorted(
set(chain(monolithicFlagsDict.keys(), modularFlagsDict.keys())))
for signature in allSignatures:
monolithicRow = monolithicFlagsDict.get(signature, {})
monolithicFlags = monolithicRow.get(None, [])
if signature in modularFlagsDict:
modularRow = modularFlagsDict.get(signature, {})
modularFlags = modularRow.get(None, [])
else:
modularFlags = ["blocked"]
if monolithicFlags != modularFlags:
mismatchingSignatures.append(
(signature, modularFlags, monolithicFlags))
return mismatchingSignatures
def main(argv):
args_parser = argparse.ArgumentParser(
description="Verify that sets of hidden API flags are each a subset of "
"the monolithic flag file.")
args_parser.add_argument("monolithicFlags", help="The monolithic flag file")
args_parser.add_argument(
"modularFlags",
nargs=argparse.REMAINDER,
help="Flags produced by individual bootclasspath_fragment modules")
args = args_parser.parse_args(argv[1:])
# Read in all the flags into the trie
monolithicFlagsPath = args.monolithicFlags
monolithicTrie = read_flag_trie_from_file(monolithicFlagsPath)
# For each subset specified on the command line, create dicts for the flags
# provided by the subset and the corresponding flags from the complete set
# of flags and compare them.
failed = False
for modularPair in args.modularFlags:
parts = modularPair.split(":")
modularFlagsPath = parts[0]
modularPatternsPath = parts[1]
modularFlagsDict = read_signature_csv_from_file_as_dict(
modularFlagsPath)
monolithicFlagsSubsetDict = \
extract_subset_from_monolithic_flags_as_dict_from_file(
monolithicTrie, modularPatternsPath)
mismatchingSignatures = compare_signature_flags(
monolithicFlagsSubsetDict, modularFlagsDict)
if mismatchingSignatures:
failed = True
print("ERROR: Hidden API flags are inconsistent:")
print("< " + modularFlagsPath)
print("> " + monolithicFlagsPath)
for mismatch in mismatchingSignatures:
signature = mismatch[0]
print()
print("< " + ",".join([signature] + mismatch[1]))
print("> " + ",".join([signature] + mismatch[2]))
if failed:
sys.exit(1)
if __name__ == "__main__":
main(sys.argv)
|