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
187
188
189
190
|
# elog/messages.py - elog core functions
# Copyright 2006-2011 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
import portage
portage.proxy.lazyimport.lazyimport(globals(),
'portage.output:colorize',
'portage.util:writemsg',
)
from portage.const import EBUILD_PHASES
from portage.localization import _
from portage import os
from portage import _encodings
from portage import _unicode_encode
from portage import _unicode_decode
import io
import sys
_log_levels = frozenset([
"ERROR",
"INFO",
"LOG",
"QA",
"WARN",
])
def collect_ebuild_messages(path):
""" Collect elog messages generated by the bash logging function stored
at 'path'.
"""
mylogfiles = None
try:
mylogfiles = os.listdir(path)
except OSError:
pass
# shortcut for packages without any messages
if not mylogfiles:
return {}
# exploit listdir() file order so we process log entries in chronological order
mylogfiles.reverse()
logentries = {}
for msgfunction in mylogfiles:
filename = os.path.join(path, msgfunction)
if msgfunction not in EBUILD_PHASES:
writemsg(_("!!! can't process invalid log file: %s\n") % filename,
noiselevel=-1)
continue
if not msgfunction in logentries:
logentries[msgfunction] = []
lastmsgtype = None
msgcontent = []
f = io.open(_unicode_encode(filename,
encoding=_encodings['fs'], errors='strict'),
mode='r', encoding=_encodings['repo.content'], errors='replace')
# Use split('\n') since normal line iteration or readlines() will
# split on \r characters as shown in bug #390833.
for l in f.read().split('\n'):
if not l:
continue
try:
msgtype, msg = l.split(" ", 1)
if msgtype not in _log_levels:
raise ValueError(msgtype)
except ValueError:
writemsg(_("!!! malformed entry in "
"log file: '%s': %s\n") % (filename, l), noiselevel=-1)
continue
if lastmsgtype is None:
lastmsgtype = msgtype
if msgtype == lastmsgtype:
msgcontent.append(msg)
else:
if msgcontent:
logentries[msgfunction].append((lastmsgtype, msgcontent))
msgcontent = [msg]
lastmsgtype = msgtype
f.close()
if msgcontent:
logentries[msgfunction].append((lastmsgtype, msgcontent))
# clean logfiles to avoid repetitions
for f in mylogfiles:
try:
os.unlink(os.path.join(path, f))
except OSError:
pass
return logentries
_msgbuffer = {}
def _elog_base(level, msg, phase="other", key=None, color=None, out=None):
""" Backend for the other messaging functions, should not be called
directly.
"""
# TODO: Have callers pass in a more unique 'key' parameter than a plain
# cpv, in order to ensure that messages are properly grouped together
# for a given package instance, and also to ensure that each elog module's
# process() function is only called once for each unique package. This is
# needed not only when building packages in parallel, but also to preserve
# continuity in messages when a package is simply updated, since we don't
# want the elog_process() call from the uninstall of the old version to
# cause discontinuity in the elog messages of the new one being installed.
global _msgbuffer
if out is None:
out = sys.stdout
if color is None:
color = "GOOD"
msg = _unicode_decode(msg,
encoding=_encodings['content'], errors='replace')
formatted_msg = colorize(color, " * ") + msg + "\n"
# avoid potential UnicodeEncodeError
if out in (sys.stdout, sys.stderr):
formatted_msg = _unicode_encode(formatted_msg,
encoding=_encodings['stdio'], errors='backslashreplace')
if sys.hexversion >= 0x3000000:
out = out.buffer
out.write(formatted_msg)
if key not in _msgbuffer:
_msgbuffer[key] = {}
if phase not in _msgbuffer[key]:
_msgbuffer[key][phase] = []
_msgbuffer[key][phase].append((level, msg))
#raise NotImplementedError()
def collect_messages(key=None, phasefilter=None):
global _msgbuffer
if key is None:
rValue = _msgbuffer
_reset_buffer()
else:
rValue = {}
if key in _msgbuffer:
if phasefilter is None:
rValue[key] = _msgbuffer.pop(key)
else:
rValue[key] = {}
for phase in phasefilter:
try:
rValue[key][phase] = _msgbuffer[key].pop(phase)
except KeyError:
pass
if not _msgbuffer[key]:
del _msgbuffer[key]
return rValue
def _reset_buffer():
""" Reset the internal message buffer when it has been processed,
should not be called directly.
"""
global _msgbuffer
_msgbuffer = {}
# creating and exporting the actual messaging functions
_functions = { "einfo": ("INFO", "GOOD"),
"elog": ("LOG", "GOOD"),
"ewarn": ("WARN", "WARN"),
"eqawarn": ("QA", "WARN"),
"eerror": ("ERROR", "BAD"),
}
class _make_msgfunction(object):
__slots__ = ('_color', '_level')
def __init__(self, level, color):
self._level = level
self._color = color
def __call__(self, msg, phase="other", key=None, out=None):
"""
Display and log a message assigned to the given key/cpv.
"""
_elog_base(self._level, msg, phase=phase,
key=key, color=self._color, out=out)
for f in _functions:
setattr(sys.modules[__name__], f, _make_msgfunction(_functions[f][0], _functions[f][1]))
del f, _functions
|
GitWeb