13
|
1 |
#
|
|
2 |
# Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
|
|
3 |
# All rights reserved.
|
|
4 |
# This component and the accompanying materials are made available
|
|
5 |
# under the terms of the License "Eclipse Public License v1.0"
|
|
6 |
# which accompanies this distribution, and is available
|
|
7 |
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
8 |
#
|
|
9 |
# Initial Contributors:
|
|
10 |
# Nokia Corporation - initial contribution.
|
|
11 |
#
|
|
12 |
# Contributors:
|
|
13 |
#
|
|
14 |
# Description:
|
|
15 |
# Filter class for filtering XML logs and generating reports
|
|
16 |
# Prints errors and warnings to stdout
|
|
17 |
#
|
|
18 |
|
|
19 |
import sys
|
|
20 |
import raptor
|
|
21 |
import filter_interface
|
|
22 |
import generic_path
|
|
23 |
import os
|
|
24 |
import os.path
|
|
25 |
import re
|
|
26 |
|
|
27 |
class Recipe(object):
|
|
28 |
"""State machine that parses a recipe
|
|
29 |
"""
|
|
30 |
|
|
31 |
suppress = []
|
|
32 |
warningRE = re.compile("^.*((Warning:)|(MAKEDEF WARNING:)) .*$", re.DOTALL | re.M | re.I)
|
|
33 |
infoRE = None
|
|
34 |
name = [ "default" ]
|
|
35 |
recipes = []
|
|
36 |
|
|
37 |
def __init__(self, text):
|
|
38 |
self.suppress = self.__class__.suppress
|
|
39 |
self.text = text
|
|
40 |
self.warningRE = Recipe.warningRE
|
|
41 |
|
|
42 |
def warnings(self):
|
|
43 |
return self.warningRE.findall(self.text)
|
|
44 |
|
|
45 |
def info(self):
|
|
46 |
if self.infoRE:
|
|
47 |
return self.infoRE.findall(self.text)
|
|
48 |
else:
|
|
49 |
return []
|
|
50 |
|
|
51 |
@classmethod
|
|
52 |
def factory(cls, name, text):
|
|
53 |
for r in Recipe.recipes:
|
|
54 |
if name in r.name:
|
|
55 |
return r(text)
|
|
56 |
return Recipe(text)
|
|
57 |
|
|
58 |
|
|
59 |
class MwLinkerRecipe(Recipe):
|
|
60 |
suppress = [
|
|
61 |
re.compile(
|
|
62 |
r"^mwldsym2: warning: Cannot locate library \"MSL_All_Static_MSE_Symbian\" specified in #pragma comment\(lib,...\)$"
|
|
63 |
r"[\n\r]*mwldsym2: warning: referenced from.*$"
|
|
64 |
r"[\n\r]*mwldsym2: warning: Option 'Use default libraries' is enabled but linker used.*$"
|
|
65 |
r"[\n\r]*mwldsym2: warning: runtime library from MW\[...\]LibraryFiles \(msl_all_static_mse_symbian_d.lib\);$"
|
|
66 |
r"[\n\r]*mwldsym2: warning: this indicates a potential settings/libraries mismatch.*$"
|
|
67 |
, re.M)
|
|
68 |
, re.compile(
|
|
69 |
r"^mwldsym2.exe: warning: Multiply defined symbol: ___get_MSL_init_count in.*$"
|
|
70 |
r"[\n\r]*mwldsym2.exe: warning: files uc_cwhelp.obj \(.*\), startup.win32.c.obj \(msl_all_static_mse_symbian_d.lib\),.*$"
|
|
71 |
r"[\n\r]*mwldsym2.exe: warning: keeping definition in startup.win32.c.obj.*$"
|
|
72 |
, re.M )
|
|
73 |
, re.compile(
|
|
74 |
r"^mwldsym2.exe: warning: Option 'Use default libraries' is enabled but linker used.*$"
|
|
75 |
r"[\n\r]*mwldsym2.exe: warning: runtime library from MW\[...\]LibraryFiles \(msl_all_static_mse_symbian_d.lib\);.*$"
|
|
76 |
r"[\n\r]*mwldsym2.exe: warning: this indicates a potential settings/libraries mismatch.*$"
|
|
77 |
, re.M)
|
|
78 |
]
|
|
79 |
name = [ "win32stagetwolink", "win32simplelink" ]
|
|
80 |
|
|
81 |
def warnings(self):
|
|
82 |
edited = self.text
|
|
83 |
for s in MwLinkerRecipe.suppress:
|
|
84 |
edited = s.sub("", edited)
|
|
85 |
return Recipe.warningRE.findall(edited)
|
|
86 |
|
|
87 |
Recipe.recipes.append(MwLinkerRecipe)
|
|
88 |
|
|
89 |
|
|
90 |
class FreezeRecipe(Recipe):
|
|
91 |
name = [ "freeze" ]
|
|
92 |
warningRE = re.compile("^(WARNING:) .*$", re.DOTALL | re.M | re.I)
|
|
93 |
infoRE = re.compile("^(EFREEZE:) .*$", re.DOTALL | re.M | re.I)
|
|
94 |
|
|
95 |
def __init__(self, text):
|
|
96 |
Recipe.__init__(self, text)
|
|
97 |
self.warningRE = FreezeRecipe.warningRE
|
|
98 |
self.infoRE = FreezeRecipe.infoRE
|
|
99 |
|
|
100 |
Recipe.recipes.append(FreezeRecipe)
|
|
101 |
|
|
102 |
|
|
103 |
|
|
104 |
class FilterTerminal(filter_interface.Filter):
|
|
105 |
|
|
106 |
attribute_re = re.compile("([a-z][a-z0-9]*)='([^']*)'",re.I)
|
|
107 |
maxdots = 40 # if one prints dots then don't print masses
|
|
108 |
recipelinelimit = 1024 # don't scan ultra-long recipes in case we run out of memory
|
|
109 |
|
|
110 |
# recipes that we think most users are interested in
|
|
111 |
# and the mapping that we will use to output them as
|
|
112 |
docare = {
|
|
113 |
"asmcompile" : "asmcompile" ,
|
|
114 |
"compile" : "compile" ,
|
|
115 |
"postlink" : "target",
|
|
116 |
"linkandpostlink" : "target",
|
|
117 |
"resourcecompile" : "resource",
|
|
118 |
"genstringtable" : "strtable",
|
|
119 |
"tem" : "tem",
|
|
120 |
"bitmapcompile" : "bitmap",
|
|
121 |
"bitmapcopy" : "bitmapcopy",
|
|
122 |
"win32compile2object" : "compile",
|
|
123 |
"win32stagetwolink" : "target",
|
|
124 |
"win32simplelink" : "target",
|
|
125 |
"tools2install" : "target",
|
|
126 |
"compile2object" : "compile",
|
|
127 |
"msvctoolsinstall" : "target",
|
|
128 |
"msvctoolscompile" : "compile",
|
|
129 |
"freeze" : "freeze",
|
|
130 |
"win32archive" : "target"
|
|
131 |
}
|
|
132 |
|
|
133 |
# Determine the width of the largest mapped recipe name
|
|
134 |
recipewidth = 0
|
|
135 |
for i in docare:
|
|
136 |
l = len(docare[i])
|
|
137 |
if l > recipewidth:
|
|
138 |
recipewidth = l # justification for printing out recipes.
|
|
139 |
recipewidth+=1
|
|
140 |
|
|
141 |
def __init__(self):
|
|
142 |
self.analyseonly = False
|
|
143 |
self.quiet = False
|
|
144 |
# defaults can use EPOCROOT
|
|
145 |
if "EPOCROOT" in os.environ:
|
|
146 |
self.epocroot = str(generic_path.Path(os.environ["EPOCROOT"]))
|
|
147 |
else:
|
|
148 |
self.epocroot = str(generic_path.Path('/'))
|
|
149 |
self.current_recipe_logged = False
|
|
150 |
self.cleaned = 0 # cleaned files
|
|
151 |
self.dotcount = 0 # progress dots printed so far
|
|
152 |
# list of strings to catch make errors (must be lowercase)
|
|
153 |
self.make_error_expr = set([
|
|
154 |
"error:",
|
|
155 |
": ***",
|
|
156 |
"make: interrupt/exception caught (code =",
|
28
|
157 |
"make.exe: interrupt/exception caught (code =",
|
|
158 |
"command returned code"
|
13
|
159 |
])
|
|
160 |
# list of strings to catch make warnings (must be lowercase)
|
|
161 |
self.make_warning_expr = ["warning:"]
|
|
162 |
|
|
163 |
# list of strings to catch recipe warnings (must be lowercase)
|
|
164 |
self.recipe_warning_expr = ["warning:"]
|
|
165 |
|
|
166 |
def isMakeWarning(self, text):
|
|
167 |
"""A simple test for warnings.
|
|
168 |
Can be extended do to more comprehensive checking."""
|
|
169 |
# generic warnings checked
|
|
170 |
# array of make_warning_expr holds all the possible values
|
|
171 |
for warn in self.make_warning_expr:
|
|
172 |
if warn in text.lower():
|
|
173 |
return True
|
|
174 |
|
|
175 |
return False
|
|
176 |
|
|
177 |
|
|
178 |
def isMakeError(self, text):
|
|
179 |
"""A simple test for errors.
|
|
180 |
Can be extended to do more comprehensive checking."""
|
|
181 |
|
|
182 |
# make, emake and pvmgmake spit out things like
|
|
183 |
# make: *** No rule to make target X, needed by Y. Stop.
|
|
184 |
#
|
|
185 |
# array of make_error_expr holds all the possible values
|
|
186 |
for err in self.make_error_expr:
|
|
187 |
if err in text.lower():
|
|
188 |
return True
|
|
189 |
|
|
190 |
return False
|
|
191 |
|
|
192 |
|
|
193 |
def open(self, raptor_instance):
|
|
194 |
"""Set output to stdout for the various I/O methods to write to."""
|
|
195 |
self.raptor = raptor_instance
|
|
196 |
|
|
197 |
# Be totally silent?
|
|
198 |
if self.raptor.logFileName is None:
|
|
199 |
self.analyseonly = True
|
|
200 |
|
|
201 |
# Only print errors and warnings?
|
|
202 |
if self.raptor.quiet:
|
|
203 |
self.quiet = True
|
|
204 |
|
|
205 |
# the build configurations which were reported
|
|
206 |
self.built_configs = []
|
|
207 |
|
|
208 |
# keep count of errors and warnings
|
|
209 |
self.err_count = 0
|
|
210 |
self.warn_count = 0
|
|
211 |
self.suppressed_warn_count = 0
|
|
212 |
self.inBody = False
|
|
213 |
self.inRecipe = False
|
|
214 |
return True
|
|
215 |
|
|
216 |
def write(self, text):
|
|
217 |
"""Write errors and warnings to stdout"""
|
|
218 |
|
|
219 |
if text.startswith("<error"):
|
|
220 |
start = text.find(">")
|
|
221 |
end = text.rfind("<")
|
|
222 |
self.err_count += 1
|
|
223 |
if not self.analyseonly:
|
|
224 |
sys.stderr.write(str(raptor.name) + ": error: %s\n" \
|
|
225 |
% text[(start + 1):end])
|
|
226 |
elif text.startswith("<warning"):
|
|
227 |
start = text.find(">")
|
|
228 |
end = text.rfind("<")
|
|
229 |
self.warn_count += 1
|
|
230 |
if not self.analyseonly:
|
|
231 |
sys.stdout.write(str(raptor.name) + ": warning: %s\n" \
|
|
232 |
% text[(start + 1):end])
|
|
233 |
elif text.startswith("<status "):
|
|
234 |
# detect the status report from a recipe
|
|
235 |
if text.find('failed') != -1:
|
|
236 |
self.failed = True
|
|
237 |
if text.find("reason='timeout'") != -1:
|
|
238 |
self.timedout = True
|
|
239 |
else:
|
|
240 |
self.failed = False
|
|
241 |
return
|
|
242 |
elif text.startswith("<recipe "):
|
|
243 |
# detect the start of a recipe
|
|
244 |
if self.inRecipe:
|
|
245 |
sys.stdout.flush()
|
|
246 |
sys.stderr.write(self.formatError("Opening recipe tag found " \
|
|
247 |
+ "before closing recipe tag for previous recipe:\n" \
|
|
248 |
+ "Discarding previous recipe (Possible logfile " \
|
|
249 |
+ "corruption)"))
|
|
250 |
sys.stderr.flush()
|
|
251 |
self.inRecipe = True
|
|
252 |
self.current_recipe_logged = False
|
|
253 |
m = FilterTerminal.attribute_re.findall(text)
|
|
254 |
self.recipe_dict = dict ()
|
|
255 |
for i in m:
|
|
256 |
self.recipe_dict[i[0]] = i[1]
|
|
257 |
|
|
258 |
# Decide what to tell the user about this recipe
|
|
259 |
# The target file or the source file?
|
|
260 |
name = None
|
|
261 |
if 'source' in self.recipe_dict:
|
|
262 |
name = self.recipe_dict['source']
|
|
263 |
|
|
264 |
name_to_user = ""
|
|
265 |
# Make source files relative to the current directory if they are
|
|
266 |
# not generated files in epocroot. Also make sure path is in
|
|
267 |
# the appropriate format for the user's shell.
|
|
268 |
if name and (name.find("epoc32") == -1 or name.endswith('.UID.CPP')):
|
|
269 |
for i in name.rsplit():
|
|
270 |
name_to_user += " " + generic_path.Path(i).From(generic_path.CurrentDir()).GetShellPath()
|
|
271 |
else:
|
|
272 |
# using the target. Shorten it if it's in epocroot by just chopping off
|
|
273 |
# epocroot
|
|
274 |
name_to_user = self.recipe_dict['target']
|
|
275 |
if name_to_user.find(self.epocroot) != -1:
|
|
276 |
name_to_user = name_to_user.replace(self.epocroot,"")
|
|
277 |
if name_to_user.startswith('/') or name_to_user.startswith('\\'):
|
|
278 |
name_to_user = name_to_user[1:]
|
|
279 |
name_to_user = generic_path.Path(name_to_user).GetShellPath()
|
|
280 |
self.recipe_dict['name_to_user'] = name_to_user
|
|
281 |
self.recipe_dict['mappedname'] = self.recipe_dict['name']
|
|
282 |
|
|
283 |
# Status message to indicate that we are building
|
|
284 |
recipename = self.recipe_dict['name']
|
|
285 |
if recipename in FilterTerminal.docare:
|
|
286 |
self.recipe_dict['mappedname'] = FilterTerminal.docare[recipename]
|
|
287 |
self.logit_if()
|
|
288 |
|
|
289 |
# This variable holds all recipe information
|
|
290 |
self.failed = False # Recipe status
|
|
291 |
self.timedout = False # Did it Timeout?
|
|
292 |
self.recipeBody = []
|
|
293 |
self.recipelineExceeded = 0
|
|
294 |
return
|
|
295 |
elif text.startswith("</recipe>"):
|
|
296 |
# detect the end of a recipe
|
|
297 |
if not self.inRecipe:
|
|
298 |
sys.stdout.flush()
|
|
299 |
sys.stderr.write(self.formatError("Closing recipe tag found " \
|
|
300 |
+ "before opening recipe tag:\nUnable to print " \
|
|
301 |
+ "recipe data (Possible logfile corruption)"))
|
|
302 |
sys.stderr.flush()
|
|
303 |
else:
|
|
304 |
self.inRecipe = False
|
|
305 |
|
|
306 |
if self.failed == True:
|
|
307 |
if not self.analyseonly:
|
|
308 |
reason=""
|
|
309 |
if self.timedout:
|
|
310 |
reason="(timeout)"
|
|
311 |
|
|
312 |
sys.stderr.write("\n FAILED %s %s for %s: %s\n" % \
|
|
313 |
(self.recipe_dict['name'],
|
|
314 |
reason,
|
|
315 |
self.recipe_dict['config'],
|
|
316 |
self.recipe_dict['name_to_user']))
|
|
317 |
|
|
318 |
mmppath = generic_path.Path(self.recipe_dict['mmp']).From(generic_path.CurrentDir()).GetShellPath()
|
|
319 |
if mmppath is not "":
|
|
320 |
sys.stderr.write(" mmp: %s\n" % mmppath)
|
|
321 |
if self.timedout:
|
|
322 |
sys.stderr.write( \
|
|
323 |
""" Timeouts may be due to network related issues (e.g. license servers),
|
|
324 |
tool bugs or abnormally large components. TALON_TIMEOUT can be adjusted
|
|
325 |
in the make engine configuration if required. Make engines may have
|
|
326 |
their own timeouts that Raptor cannot influence
|
|
327 |
""")
|
|
328 |
else:
|
|
329 |
for L in self.recipeBody:
|
|
330 |
if not L.startswith('+'):
|
|
331 |
sys.stdout.write(" %s\n" % L.rstrip())
|
|
332 |
self.err_count += 1
|
|
333 |
else:
|
|
334 |
r = Recipe.factory(self.recipe_dict['name'], "".join(self.recipeBody))
|
|
335 |
warnings = r.warnings()
|
|
336 |
info = r.info()
|
|
337 |
if len(warnings) or len(info):
|
|
338 |
if not self.analyseonly:
|
|
339 |
for L in self.recipeBody:
|
|
340 |
if not L.startswith('+'):
|
|
341 |
sys.stdout.write(" %s\n" % L.rstrip())
|
|
342 |
self.warn_count += len(warnings)
|
|
343 |
|
|
344 |
self.recipeBody = []
|
|
345 |
return
|
|
346 |
elif not self.inRecipe and self.isMakeError(text):
|
|
347 |
# these two statements pick up errors coming from make
|
|
348 |
self.err_count += 1
|
|
349 |
sys.stderr.write(" %s\n" % text.rstrip())
|
|
350 |
return
|
|
351 |
elif not self.inRecipe and self.isMakeWarning(text):
|
|
352 |
self.warn_count += 1
|
|
353 |
sys.stdout.write(" %s\n" % text.rstrip())
|
|
354 |
return
|
|
355 |
elif text.startswith("<![CDATA["):
|
|
356 |
# save CDATA body during a recipe
|
|
357 |
if self.inRecipe:
|
|
358 |
self.inBody = True
|
|
359 |
elif text.startswith("]]>"):
|
|
360 |
if self.inRecipe:
|
|
361 |
self.inBody = False
|
|
362 |
if self.recipelineExceeded > 0:
|
|
363 |
self.recipeBody.append("[filter_terminal: OUTPUT TRUNCATED: " + \
|
|
364 |
"Recipe output limit exceeded; see logfile for full output " + \
|
|
365 |
"(%s lines shown out of %s)]" % (FilterTerminal.recipelinelimit, \
|
|
366 |
FilterTerminal.recipelinelimit + self.recipelineExceeded))
|
|
367 |
elif text.startswith("<info>Copied"):
|
|
368 |
if not self.analyseonly and not self.quiet:
|
|
369 |
start = text.find(" to ") + 4
|
|
370 |
end = text.find("</info>",start)
|
|
371 |
short_target = text[start:end]
|
|
372 |
if short_target.startswith(self.epocroot):
|
|
373 |
short_target = short_target.replace(self.epocroot,"")[1:]
|
|
374 |
short_target = generic_path.Path(short_target).GetShellPath()
|
|
375 |
sys.stdout.write(" %s: %s\n" % ("export".ljust(FilterTerminal.recipewidth), short_target))
|
|
376 |
return
|
|
377 |
elif text.find("<rm files") != -1 or text.find("<rmdir ") != -1:
|
|
378 |
# search for cleaning output but only if we
|
|
379 |
# are not in some recipe (that would be pointless)
|
|
380 |
if not self.analyseonly and not self.quiet:
|
|
381 |
if self.cleaned == 0:
|
|
382 |
sys.stdout.write("\ncleaning ")
|
|
383 |
self.cleaned+=1
|
|
384 |
elif self.dotcount < FilterTerminal.maxdots:
|
|
385 |
if self.cleaned % 5 == 0:
|
|
386 |
self.dotcount+=1
|
|
387 |
sys.stdout.write(".")
|
|
388 |
self.cleaned+=1
|
|
389 |
|
|
390 |
return
|
|
391 |
elif self.inBody:
|
|
392 |
# We are parsing the output from a recipe
|
|
393 |
# we have to keep the output until we find out
|
|
394 |
# if the recipe failed. But not all of it if it turns
|
|
395 |
# out to be very long
|
|
396 |
if len(self.recipeBody) <= FilterTerminal.recipelinelimit:
|
|
397 |
self.recipeBody.append(text)
|
|
398 |
else:
|
|
399 |
self.recipelineExceeded += 1
|
|
400 |
elif text.startswith("<info>Buildable configuration '"):
|
|
401 |
# <info>Buildable configuration 'name'</info>
|
|
402 |
self.built_configs.append(text[30:-8])
|
|
403 |
|
|
404 |
def logit(self):
|
|
405 |
""" log a message """
|
|
406 |
info = self.recipe_dict['mappedname'].ljust(FilterTerminal.recipewidth)
|
|
407 |
config = self.recipe_dict['config']
|
|
408 |
name = self.recipe_dict['name_to_user'].lstrip()
|
|
409 |
# If its a multifile config, we print source files one below the other in a single
|
|
410 |
# 'compile:' statement
|
|
411 |
if config.endswith('multifile'):
|
|
412 |
files = self.recipe_dict['name_to_user'].split()
|
|
413 |
name = ""
|
|
414 |
for i in files:
|
|
415 |
if i == files[0]:
|
|
416 |
name += i
|
|
417 |
else:
|
|
418 |
name += '\n\t ' + i
|
|
419 |
sys.stdout.write(" %s: %s \t[%s]\n" % (info, name, config))
|
|
420 |
|
|
421 |
def logit_if(self):
|
|
422 |
""" Tell the user about the recipe that we are processing """
|
|
423 |
if not self.analyseonly and not self.quiet:
|
|
424 |
if self.inRecipe and not self.current_recipe_logged:
|
|
425 |
self.logit()
|
|
426 |
self.current_recipe_logged = True
|
|
427 |
|
|
428 |
def summary(self):
|
|
429 |
"""Errors and warnings summary"""
|
|
430 |
|
|
431 |
if self.raptor.skipAll or self.analyseonly:
|
|
432 |
return
|
|
433 |
|
|
434 |
|
|
435 |
if self.cleaned != 0:
|
|
436 |
sys.stdout.write("\n\n")
|
|
437 |
|
|
438 |
if self.warn_count > 0 or self.err_count > 0:
|
|
439 |
sys.stdout.write("\n%s : warnings: %s\n" % (raptor.name,
|
|
440 |
self.warn_count))
|
|
441 |
sys.stdout.write("%s : errors: %s\n\n" % (raptor.name,
|
|
442 |
self.err_count))
|
|
443 |
else:
|
|
444 |
sys.stdout.write("\nno warnings or errors\n\n")
|
|
445 |
|
|
446 |
for bc in self.built_configs:
|
|
447 |
sys.stdout.write("built " + bc + "\n")
|
|
448 |
|
|
449 |
sys.stdout.write("\nRun time %d seconds\n" % self.raptor.runtime);
|
|
450 |
sys.stdout.write("\n")
|
|
451 |
return True
|
|
452 |
|
|
453 |
def close(self):
|
|
454 |
"""Tell raptor that there were errors."""
|
|
455 |
if self.err_count > 0:
|
|
456 |
return False
|
|
457 |
return True
|
|
458 |
|