2005-08-31 10:47:56 +00:00
|
|
|
# ex:ts=4:sw=4:sts=4:et
|
|
|
|
# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
|
|
|
|
"""
|
|
|
|
BitBake 'Event' implementation
|
|
|
|
|
|
|
|
Classes and functions for manipulating 'events' in the
|
|
|
|
BitBake build tools.
|
|
|
|
"""
|
|
|
|
|
2007-01-08 23:53:01 +00:00
|
|
|
# Copyright (C) 2003, 2004 Chris Larson
|
|
|
|
#
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU General Public License version 2 as
|
|
|
|
# published by the Free Software Foundation.
|
|
|
|
#
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
# GNU General Public License for more details.
|
|
|
|
#
|
|
|
|
# You should have received a copy of the GNU General Public License along
|
|
|
|
# with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
|
2010-04-08 17:22:29 +00:00
|
|
|
import os, sys
|
2010-04-08 23:30:52 +00:00
|
|
|
import warnings
|
2016-05-12 07:30:35 +00:00
|
|
|
import pickle
|
2010-06-09 23:17:29 +00:00
|
|
|
import logging
|
2010-09-28 15:24:55 +00:00
|
|
|
import atexit
|
2011-05-06 00:43:38 +00:00
|
|
|
import traceback
|
2015-12-20 13:22:19 +00:00
|
|
|
import ast
|
2010-06-09 23:17:29 +00:00
|
|
|
import bb.utils
|
2012-09-10 22:23:19 +00:00
|
|
|
import bb.compat
|
2013-06-07 17:11:09 +00:00
|
|
|
import bb.exceptions
|
2010-01-20 18:46:02 +00:00
|
|
|
|
|
|
|
# This is the pid for which we should generate the event. This is set when
|
|
|
|
# the runqueue forks off.
|
|
|
|
worker_pid = 0
|
2013-06-07 17:11:09 +00:00
|
|
|
worker_fire = None
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2011-04-04 18:31:39 +00:00
|
|
|
logger = logging.getLogger('BitBake.Event')
|
|
|
|
|
2010-09-10 00:57:51 +00:00
|
|
|
class Event(object):
|
2005-08-31 10:47:56 +00:00
|
|
|
"""Base class for events"""
|
|
|
|
|
2010-01-20 18:46:02 +00:00
|
|
|
def __init__(self):
|
|
|
|
self.pid = worker_pid
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2006-05-09 15:44:08 +00:00
|
|
|
Registered = 10
|
|
|
|
AlreadyRegistered = 14
|
|
|
|
|
2013-05-23 09:50:30 +00:00
|
|
|
def get_class_handlers():
|
|
|
|
return _handlers
|
|
|
|
|
|
|
|
def set_class_handlers(h):
|
2014-12-08 10:50:25 +00:00
|
|
|
global _handlers
|
2013-05-23 09:50:30 +00:00
|
|
|
_handlers = h
|
|
|
|
|
|
|
|
def clean_class_handlers():
|
|
|
|
return bb.compat.OrderedDict()
|
|
|
|
|
2006-05-09 15:44:08 +00:00
|
|
|
# Internal
|
2013-05-23 09:50:30 +00:00
|
|
|
_handlers = clean_class_handlers()
|
2010-01-20 18:46:02 +00:00
|
|
|
_ui_handlers = {}
|
2013-08-23 14:55:21 +00:00
|
|
|
_ui_logfilters = {}
|
2010-01-20 18:46:02 +00:00
|
|
|
_ui_handler_seq = 0
|
2013-05-31 14:19:14 +00:00
|
|
|
_event_handler_map = {}
|
|
|
|
_catchall_handlers = {}
|
2014-12-08 10:50:24 +00:00
|
|
|
_eventfilter = None
|
2015-09-03 14:20:05 +00:00
|
|
|
_uiready = False
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2016-04-30 19:43:53 +00:00
|
|
|
if hasattr(__builtins__, '__setitem__'):
|
|
|
|
builtins = __builtins__
|
|
|
|
else:
|
|
|
|
builtins = __builtins__.__dict__
|
|
|
|
|
2011-04-04 18:31:39 +00:00
|
|
|
def execute_handler(name, handler, event, d):
|
|
|
|
event.data = d
|
2015-06-25 21:52:17 +00:00
|
|
|
addedd = False
|
2016-04-30 19:43:53 +00:00
|
|
|
if 'd' not in builtins:
|
|
|
|
builtins['d'] = d
|
2015-06-25 21:52:17 +00:00
|
|
|
addedd = True
|
2011-04-04 18:31:39 +00:00
|
|
|
try:
|
|
|
|
ret = handler(event)
|
2014-05-30 14:55:37 +00:00
|
|
|
except (bb.parse.SkipRecipe, bb.BBHandledException):
|
2011-09-02 12:58:54 +00:00
|
|
|
raise
|
2011-04-04 18:31:39 +00:00
|
|
|
except Exception:
|
|
|
|
etype, value, tb = sys.exc_info()
|
|
|
|
logger.error("Execution of event handler '%s' failed" % name,
|
|
|
|
exc_info=(etype, value, tb.tb_next))
|
|
|
|
raise
|
|
|
|
except SystemExit as exc:
|
|
|
|
if exc.code != 0:
|
|
|
|
logger.error("Execution of event handler '%s' failed" % name)
|
|
|
|
raise
|
|
|
|
finally:
|
|
|
|
del event.data
|
2015-06-25 21:52:17 +00:00
|
|
|
if addedd:
|
2016-04-30 19:43:53 +00:00
|
|
|
del builtins['d']
|
2011-04-04 18:31:39 +00:00
|
|
|
|
2010-03-25 17:33:41 +00:00
|
|
|
def fire_class_handlers(event, d):
|
2010-12-10 16:04:08 +00:00
|
|
|
if isinstance(event, logging.LogRecord):
|
2010-04-09 22:56:14 +00:00
|
|
|
return
|
|
|
|
|
2013-05-31 14:19:14 +00:00
|
|
|
eid = str(event.__class__)[8:-2]
|
|
|
|
evt_hmap = _event_handler_map.get(eid, {})
|
2016-05-12 07:30:35 +00:00
|
|
|
for name, handler in list(_handlers.items()):
|
2013-05-31 14:19:14 +00:00
|
|
|
if name in _catchall_handlers or name in evt_hmap:
|
2014-12-08 10:50:24 +00:00
|
|
|
if _eventfilter:
|
|
|
|
if not _eventfilter(name, handler, event, d):
|
|
|
|
continue
|
2014-05-30 14:52:59 +00:00
|
|
|
execute_handler(name, handler, event, d)
|
2010-01-20 18:46:02 +00:00
|
|
|
|
2010-09-28 15:24:55 +00:00
|
|
|
ui_queue = []
|
|
|
|
@atexit.register
|
|
|
|
def print_ui_queue():
|
|
|
|
"""If we're exiting before a UI has been spawned, display any queued
|
|
|
|
LogRecords to the console."""
|
|
|
|
logger = logging.getLogger("BitBake")
|
2015-09-03 14:20:05 +00:00
|
|
|
if not _uiready:
|
2011-01-05 18:20:05 +00:00
|
|
|
from bb.msg import BBLogFormatter
|
2010-09-28 15:24:55 +00:00
|
|
|
console = logging.StreamHandler(sys.stdout)
|
2011-01-05 18:20:05 +00:00
|
|
|
console.setFormatter(BBLogFormatter("%(levelname)s: %(message)s"))
|
2010-09-28 15:24:55 +00:00
|
|
|
logger.handlers = [console]
|
2012-09-11 09:37:22 +00:00
|
|
|
|
|
|
|
# First check to see if we have any proper messages
|
|
|
|
msgprint = False
|
|
|
|
for event in ui_queue:
|
|
|
|
if isinstance(event, logging.LogRecord):
|
|
|
|
if event.levelno > logging.DEBUG:
|
|
|
|
logger.handle(event)
|
|
|
|
msgprint = True
|
|
|
|
if msgprint:
|
|
|
|
return
|
|
|
|
|
|
|
|
# Nope, so just print all of the messages we have (including debug messages)
|
2011-07-21 20:23:19 +00:00
|
|
|
for event in ui_queue:
|
2010-09-28 15:24:55 +00:00
|
|
|
if isinstance(event, logging.LogRecord):
|
|
|
|
logger.handle(event)
|
|
|
|
|
2010-03-25 17:33:41 +00:00
|
|
|
def fire_ui_handlers(event, d):
|
2015-09-03 14:20:05 +00:00
|
|
|
if not _uiready:
|
2010-09-28 15:24:55 +00:00
|
|
|
# No UI handlers registered yet, queue up the messages
|
2010-09-28 15:52:32 +00:00
|
|
|
ui_queue.append(event)
|
2010-09-28 15:24:55 +00:00
|
|
|
return
|
|
|
|
|
2010-01-20 18:46:02 +00:00
|
|
|
errors = []
|
|
|
|
for h in _ui_handlers:
|
|
|
|
#print "Sending event %s" % event
|
|
|
|
try:
|
2013-08-23 14:55:21 +00:00
|
|
|
if not _ui_logfilters[h].filter(event):
|
|
|
|
continue
|
2010-01-20 18:46:02 +00:00
|
|
|
# We use pickle here since it better handles object instances
|
|
|
|
# which xmlrpc's marshaller does not. Events *must* be serializable
|
|
|
|
# by pickle.
|
2011-06-08 10:19:40 +00:00
|
|
|
if hasattr(_ui_handlers[h].event, "sendpickle"):
|
|
|
|
_ui_handlers[h].event.sendpickle((pickle.dumps(event)))
|
|
|
|
else:
|
|
|
|
_ui_handlers[h].event.send(event)
|
2010-01-20 18:46:02 +00:00
|
|
|
except:
|
|
|
|
errors.append(h)
|
|
|
|
for h in errors:
|
|
|
|
del _ui_handlers[h]
|
|
|
|
|
2010-03-25 17:33:41 +00:00
|
|
|
def fire(event, d):
|
|
|
|
"""Fire off an Event"""
|
|
|
|
|
2010-03-24 23:56:12 +00:00
|
|
|
# We can fire class handlers in the worker process context and this is
|
2010-03-25 17:33:41 +00:00
|
|
|
# desired so they get the task based datastore.
|
2010-03-24 23:56:12 +00:00
|
|
|
# UI handlers need to be fired in the server context so we defer this. They
|
2010-03-25 17:33:41 +00:00
|
|
|
# don't have a datastore so the datastore context isn't a problem.
|
|
|
|
|
|
|
|
fire_class_handlers(event, d)
|
2013-06-07 17:11:09 +00:00
|
|
|
if worker_fire:
|
2010-03-25 17:33:41 +00:00
|
|
|
worker_fire(event, d)
|
|
|
|
else:
|
|
|
|
fire_ui_handlers(event, d)
|
|
|
|
|
2010-01-20 18:46:02 +00:00
|
|
|
def fire_from_worker(event, d):
|
2010-03-25 17:33:41 +00:00
|
|
|
fire_ui_handlers(event, d)
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2011-04-04 20:51:51 +00:00
|
|
|
noop = lambda _: None
|
bitbake: ast/event/utils: Improve tracebacks to include file and line numbers more correctly
Currently bitbake tracebacks can have places where the line numbers are
inaccurate and filenames may be missing. These changes start to try and
correct this.
The only way I could find to correct line numbers was to compile as a
python ast, tweak the line numbers then compile to bytecode. I'm open
to better ways of doing this if anyone knows of any.
This does mean passing a few more parameters into functions, and putting
more data into the data store about functions (i.e. their filenames
and line numbers) but the improvement in debugging is more than worthwhile).
Before:
----------------
ERROR: Execution of event handler 'run_buildstats' failed
Traceback (most recent call last):
File "run_buildstats(e)", line 43, in run_buildstats(e=<bb.build.TaskStarted object at 0x7f7b7c57a590>)
NameError: global name 'notexist' is not defined
ERROR: Build of do_patch failed
ERROR: Traceback (most recent call last):
File "/media/build1/poky/bitbake/lib/bb/build.py", line 560, in exec_task
return _exec_task(fn, task, d, quieterr)
File "/media/build1/poky/bitbake/lib/bb/build.py", line 497, in _exec_task
event.fire(TaskStarted(task, logfn, flags, localdata), localdata)
File "/media/build1/poky/bitbake/lib/bb/event.py", line 170, in fire
fire_class_handlers(event, d)
File "/media/build1/poky/bitbake/lib/bb/event.py", line 109, in fire_class_handlers
execute_handler(name, handler, event, d)
File "/media/build1/poky/bitbake/lib/bb/event.py", line 81, in execute_handler
ret = handler(event)
File "run_buildstats(e)", line 43, in run_buildstats
NameError: global name 'notexist' is not defined
----------------
After:
----------------
ERROR: Execution of event handler 'run_buildstats' failed
Traceback (most recent call last):
File "/media/build1/poky/meta/classes/buildstats.bbclass", line 143, in run_buildstats(e=<bb.build.TaskStarted object at 0x7efe89284e10>):
if isinstance(e, bb.build.TaskStarted):
> trigger = notexist
pn = d.getVar("PN", True)
NameError: global name 'notexist' is not defined
ERROR: Build of do_package failed
ERROR: Traceback (most recent call last):
File "/media/build1/poky/bitbake/lib/bb/build.py", line 560, in exec_task
return _exec_task(fn, task, d, quieterr)
File "/media/build1/poky/bitbake/lib/bb/build.py", line 497, in _exec_task
event.fire(TaskStarted(task, logfn, flags, localdata), localdata)
File "/media/build1/poky/bitbake/lib/bb/event.py", line 170, in fire
fire_class_handlers(event, d)
File "/media/build1/poky/bitbake/lib/bb/event.py", line 109, in fire_class_handlers
execute_handler(name, handler, event, d)
File "/media/build1/poky/bitbake/lib/bb/event.py", line 81, in execute_handler
ret = handler(event)
File "/media/build1/poky/meta/classes/buildstats.bbclass", line 143, in run_buildstats
trigger = notexist
NameError: global name 'notexist' is not defined
----------------
(Bitbake rev: 1ff860960919ff6f8097138bc68de85bcb5f88b0)
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2015-12-15 17:41:12 +00:00
|
|
|
def register(name, handler, mask=None, filename=None, lineno=None):
|
2005-08-31 10:47:56 +00:00
|
|
|
"""Register an Event handler"""
|
2006-05-09 15:44:08 +00:00
|
|
|
|
|
|
|
# already registered
|
2010-01-20 18:46:02 +00:00
|
|
|
if name in _handlers:
|
2006-05-09 15:44:08 +00:00
|
|
|
return AlreadyRegistered
|
|
|
|
|
2005-08-31 10:47:56 +00:00
|
|
|
if handler is not None:
|
2010-01-20 18:46:02 +00:00
|
|
|
# handle string containing python code
|
2016-05-12 07:30:35 +00:00
|
|
|
if isinstance(handler, str):
|
2011-04-04 18:31:39 +00:00
|
|
|
tmp = "def %s(e):\n%s" % (name, handler)
|
2011-04-04 20:51:51 +00:00
|
|
|
try:
|
2015-12-20 13:22:19 +00:00
|
|
|
code = bb.methodpool.compile_cache(tmp)
|
|
|
|
if not code:
|
|
|
|
if filename is None:
|
|
|
|
filename = "%s(e)" % name
|
|
|
|
code = compile(tmp, filename, "exec", ast.PyCF_ONLY_AST)
|
|
|
|
if lineno is not None:
|
|
|
|
ast.increment_lineno(code, lineno-1)
|
|
|
|
code = compile(code, filename, "exec")
|
|
|
|
bb.methodpool.compile_cache_add(tmp, code)
|
2011-04-04 20:51:51 +00:00
|
|
|
except SyntaxError:
|
|
|
|
logger.error("Unable to register event handler '%s':\n%s", name,
|
|
|
|
''.join(traceback.format_exc(limit=0)))
|
|
|
|
_handlers[name] = noop
|
|
|
|
return
|
2011-04-04 16:41:41 +00:00
|
|
|
env = {}
|
2012-08-21 16:25:07 +00:00
|
|
|
bb.utils.better_exec(code, env)
|
2011-04-04 18:31:39 +00:00
|
|
|
func = bb.utils.better_eval(name, env)
|
2011-04-04 16:41:41 +00:00
|
|
|
_handlers[name] = func
|
2006-05-09 15:44:08 +00:00
|
|
|
else:
|
2010-01-20 18:46:02 +00:00
|
|
|
_handlers[name] = handler
|
2006-05-09 15:44:08 +00:00
|
|
|
|
2013-08-23 16:16:50 +00:00
|
|
|
if not mask or '*' in mask:
|
2013-05-31 14:19:14 +00:00
|
|
|
_catchall_handlers[name] = True
|
|
|
|
else:
|
|
|
|
for m in mask:
|
|
|
|
if _event_handler_map.get(m, None) is None:
|
|
|
|
_event_handler_map[m] = {}
|
|
|
|
_event_handler_map[m][name] = True
|
|
|
|
|
2006-05-09 15:44:08 +00:00
|
|
|
return Registered
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2006-05-09 15:44:08 +00:00
|
|
|
def remove(name, handler):
|
2005-08-31 10:47:56 +00:00
|
|
|
"""Remove an Event handler"""
|
2010-01-20 18:46:02 +00:00
|
|
|
_handlers.pop(name)
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2014-12-08 10:50:24 +00:00
|
|
|
def set_eventfilter(func):
|
|
|
|
global _eventfilter
|
|
|
|
_eventfilter = func
|
|
|
|
|
2015-09-03 14:20:05 +00:00
|
|
|
def register_UIHhandler(handler, mainui=False):
|
|
|
|
if mainui:
|
|
|
|
global _uiready
|
|
|
|
_uiready = True
|
2010-01-20 18:46:02 +00:00
|
|
|
bb.event._ui_handler_seq = bb.event._ui_handler_seq + 1
|
|
|
|
_ui_handlers[_ui_handler_seq] = handler
|
2013-08-23 14:55:21 +00:00
|
|
|
level, debug_domains = bb.msg.constructLogOptions()
|
|
|
|
_ui_logfilters[_ui_handler_seq] = UIEventFilter(level, debug_domains)
|
2010-01-20 18:46:02 +00:00
|
|
|
return _ui_handler_seq
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2010-01-20 18:46:02 +00:00
|
|
|
def unregister_UIHhandler(handlerNum):
|
|
|
|
if handlerNum in _ui_handlers:
|
|
|
|
del _ui_handlers[handlerNum]
|
|
|
|
return
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2013-08-23 14:55:21 +00:00
|
|
|
# Class to allow filtering of events and specific filtering of LogRecords *before* we put them over the IPC
|
|
|
|
class UIEventFilter(object):
|
|
|
|
def __init__(self, level, debug_domains):
|
|
|
|
self.update(None, level, debug_domains)
|
|
|
|
|
|
|
|
def update(self, eventmask, level, debug_domains):
|
2013-08-23 16:16:50 +00:00
|
|
|
self.eventmask = eventmask
|
2013-08-23 14:55:21 +00:00
|
|
|
self.stdlevel = level
|
|
|
|
self.debug_domains = debug_domains
|
|
|
|
|
|
|
|
def filter(self, event):
|
|
|
|
if isinstance(event, logging.LogRecord):
|
|
|
|
if event.levelno >= self.stdlevel:
|
|
|
|
return True
|
|
|
|
if event.name in self.debug_domains and event.levelno >= self.debug_domains[event.name]:
|
|
|
|
return True
|
|
|
|
return False
|
2013-08-23 16:16:50 +00:00
|
|
|
eid = str(event.__class__)[8:-2]
|
2013-08-27 08:00:33 +00:00
|
|
|
if self.eventmask and eid not in self.eventmask:
|
2013-08-23 16:16:50 +00:00
|
|
|
return False
|
2013-08-23 14:55:21 +00:00
|
|
|
return True
|
|
|
|
|
2013-08-23 16:16:50 +00:00
|
|
|
def set_UIHmask(handlerNum, level, debug_domains, mask):
|
|
|
|
if not handlerNum in _ui_handlers:
|
|
|
|
return False
|
|
|
|
if '*' in mask:
|
|
|
|
_ui_logfilters[handlerNum].update(None, level, debug_domains)
|
|
|
|
else:
|
|
|
|
_ui_logfilters[handlerNum].update(mask, level, debug_domains)
|
|
|
|
return True
|
|
|
|
|
2005-08-31 10:47:56 +00:00
|
|
|
def getName(e):
|
|
|
|
"""Returns the name of a class or class instance"""
|
|
|
|
if getattr(e, "__name__", None) == None:
|
|
|
|
return e.__class__.__name__
|
|
|
|
else:
|
|
|
|
return e.__name__
|
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class OperationStarted(Event):
|
|
|
|
"""An operation has begun"""
|
|
|
|
def __init__(self, msg = "Operation Started"):
|
|
|
|
Event.__init__(self)
|
|
|
|
self.msg = msg
|
|
|
|
|
|
|
|
class OperationCompleted(Event):
|
|
|
|
"""An operation has completed"""
|
|
|
|
def __init__(self, total, msg = "Operation Completed"):
|
|
|
|
Event.__init__(self)
|
|
|
|
self.total = total
|
|
|
|
self.msg = msg
|
|
|
|
|
|
|
|
class OperationProgress(Event):
|
|
|
|
"""An operation is in progress"""
|
|
|
|
def __init__(self, current, total, msg = "Operation in Progress"):
|
|
|
|
Event.__init__(self)
|
|
|
|
self.current = current
|
|
|
|
self.total = total
|
|
|
|
self.msg = msg + ": %s/%s" % (current, total);
|
|
|
|
|
2007-08-03 13:40:52 +00:00
|
|
|
class ConfigParsed(Event):
|
|
|
|
"""Configuration Parsing Complete"""
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2011-06-09 16:30:17 +00:00
|
|
|
class RecipeEvent(Event):
|
2010-01-20 18:46:02 +00:00
|
|
|
def __init__(self, fn):
|
2009-11-03 23:20:15 +00:00
|
|
|
self.fn = fn
|
2010-01-20 18:46:02 +00:00
|
|
|
Event.__init__(self)
|
2009-11-03 23:20:15 +00:00
|
|
|
|
2011-06-09 16:30:17 +00:00
|
|
|
class RecipePreFinalise(RecipeEvent):
|
|
|
|
""" Recipe Parsing Complete but not yet finialised"""
|
|
|
|
|
|
|
|
class RecipeParsed(RecipeEvent):
|
|
|
|
""" Recipe Parsing Complete """
|
|
|
|
|
2008-03-03 22:01:45 +00:00
|
|
|
class StampUpdate(Event):
|
|
|
|
"""Trigger for any adjustment of the stamp files to happen"""
|
|
|
|
|
2010-01-20 18:46:02 +00:00
|
|
|
def __init__(self, targets, stampfns):
|
2008-03-03 22:01:45 +00:00
|
|
|
self._targets = targets
|
|
|
|
self._stampfns = stampfns
|
2010-01-20 18:46:02 +00:00
|
|
|
Event.__init__(self)
|
2008-03-03 22:01:45 +00:00
|
|
|
|
|
|
|
def getStampPrefix(self):
|
|
|
|
return self._stampfns
|
|
|
|
|
|
|
|
def getTargets(self):
|
|
|
|
return self._targets
|
|
|
|
|
|
|
|
stampPrefix = property(getStampPrefix)
|
|
|
|
targets = property(getTargets)
|
|
|
|
|
2005-08-31 10:47:56 +00:00
|
|
|
class BuildBase(Event):
|
|
|
|
"""Base class for bbmake run events"""
|
|
|
|
|
2010-01-20 18:46:02 +00:00
|
|
|
def __init__(self, n, p, failures = 0):
|
2005-08-31 10:47:56 +00:00
|
|
|
self._name = n
|
|
|
|
self._pkgs = p
|
2010-01-20 18:46:02 +00:00
|
|
|
Event.__init__(self)
|
2006-03-20 17:45:11 +00:00
|
|
|
self._failures = failures
|
2005-08-31 10:47:56 +00:00
|
|
|
|
|
|
|
def getPkgs(self):
|
|
|
|
return self._pkgs
|
|
|
|
|
|
|
|
def setPkgs(self, pkgs):
|
|
|
|
self._pkgs = pkgs
|
|
|
|
|
|
|
|
def getName(self):
|
|
|
|
return self._name
|
|
|
|
|
|
|
|
def setName(self, name):
|
|
|
|
self._name = name
|
|
|
|
|
|
|
|
def getCfg(self):
|
|
|
|
return self.data
|
|
|
|
|
|
|
|
def setCfg(self, cfg):
|
|
|
|
self.data = cfg
|
|
|
|
|
2006-03-20 17:45:11 +00:00
|
|
|
def getFailures(self):
|
|
|
|
"""
|
|
|
|
Return the number of failed packages
|
|
|
|
"""
|
|
|
|
return self._failures
|
|
|
|
|
2005-08-31 10:47:56 +00:00
|
|
|
pkgs = property(getPkgs, setPkgs, None, "pkgs property")
|
|
|
|
name = property(getName, setName, None, "name property")
|
|
|
|
cfg = property(getCfg, setCfg, None, "cfg property")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class BuildStarted(BuildBase, OperationStarted):
|
2005-08-31 10:47:56 +00:00
|
|
|
"""bbmake build run started"""
|
2012-02-23 13:47:16 +00:00
|
|
|
def __init__(self, n, p, failures = 0):
|
|
|
|
OperationStarted.__init__(self, "Building Started")
|
|
|
|
BuildBase.__init__(self, n, p, failures)
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class BuildCompleted(BuildBase, OperationCompleted):
|
2005-08-31 10:47:56 +00:00
|
|
|
"""bbmake build run completed"""
|
2015-08-26 12:50:47 +00:00
|
|
|
def __init__(self, total, n, p, failures=0, interrupted=0):
|
2012-02-23 13:47:16 +00:00
|
|
|
if not failures:
|
|
|
|
OperationCompleted.__init__(self, total, "Building Succeeded")
|
|
|
|
else:
|
|
|
|
OperationCompleted.__init__(self, total, "Building Failed")
|
2015-08-26 12:50:47 +00:00
|
|
|
self._interrupted = interrupted
|
2012-02-23 13:47:16 +00:00
|
|
|
BuildBase.__init__(self, n, p, failures)
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2012-07-27 08:38:02 +00:00
|
|
|
class DiskFull(Event):
|
|
|
|
"""Disk full case build aborted"""
|
|
|
|
def __init__(self, dev, type, freespace, mountpoint):
|
|
|
|
Event.__init__(self)
|
|
|
|
self._dev = dev
|
|
|
|
self._type = type
|
|
|
|
self._free = freespace
|
|
|
|
self._mountpoint = mountpoint
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2006-03-20 17:45:11 +00:00
|
|
|
class NoProvider(Event):
|
|
|
|
"""No Provider for an Event"""
|
|
|
|
|
2015-08-17 11:12:16 +00:00
|
|
|
def __init__(self, item, runtime=False, dependees=None, reasons=None, close_matches=None):
|
2010-01-20 18:46:02 +00:00
|
|
|
Event.__init__(self)
|
2006-03-20 17:45:11 +00:00
|
|
|
self._item = item
|
|
|
|
self._runtime = runtime
|
2010-06-08 20:20:35 +00:00
|
|
|
self._dependees = dependees
|
2011-07-25 13:54:41 +00:00
|
|
|
self._reasons = reasons
|
2013-08-09 13:52:05 +00:00
|
|
|
self._close_matches = close_matches
|
2006-03-20 17:45:11 +00:00
|
|
|
|
|
|
|
def getItem(self):
|
|
|
|
return self._item
|
|
|
|
|
|
|
|
def isRuntime(self):
|
|
|
|
return self._runtime
|
2005-08-31 10:47:56 +00:00
|
|
|
|
2006-03-20 17:45:11 +00:00
|
|
|
class MultipleProviders(Event):
|
2005-08-31 10:47:56 +00:00
|
|
|
"""Multiple Providers"""
|
|
|
|
|
2010-01-20 18:46:02 +00:00
|
|
|
def __init__(self, item, candidates, runtime = False):
|
|
|
|
Event.__init__(self)
|
2006-03-20 17:45:11 +00:00
|
|
|
self._item = item
|
|
|
|
self._candidates = candidates
|
|
|
|
self._is_runtime = runtime
|
|
|
|
|
|
|
|
def isRuntime(self):
|
|
|
|
"""
|
|
|
|
Is this a runtime issue?
|
|
|
|
"""
|
|
|
|
return self._is_runtime
|
|
|
|
|
|
|
|
def getItem(self):
|
|
|
|
"""
|
|
|
|
The name for the to be build item
|
|
|
|
"""
|
|
|
|
return self._item
|
|
|
|
|
|
|
|
def getCandidates(self):
|
|
|
|
"""
|
|
|
|
Get the possible Candidates for a PROVIDER.
|
|
|
|
"""
|
|
|
|
return self._candidates
|
2010-01-20 18:46:02 +00:00
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class ParseStarted(OperationStarted):
|
2010-11-19 05:47:36 +00:00
|
|
|
"""Recipe parsing for the runqueue has begun"""
|
2010-11-30 15:25:13 +00:00
|
|
|
def __init__(self, total):
|
2012-02-23 13:47:16 +00:00
|
|
|
OperationStarted.__init__(self, "Recipe parsing Started")
|
2010-11-19 05:47:36 +00:00
|
|
|
self.total = total
|
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class ParseCompleted(OperationCompleted):
|
2010-11-19 05:47:36 +00:00
|
|
|
"""Recipe parsing for the runqueue has completed"""
|
2010-01-20 18:46:02 +00:00
|
|
|
def __init__(self, cached, parsed, skipped, masked, virtuals, errors, total):
|
2012-02-23 13:47:16 +00:00
|
|
|
OperationCompleted.__init__(self, total, "Recipe parsing Completed")
|
2010-01-20 18:46:02 +00:00
|
|
|
self.cached = cached
|
|
|
|
self.parsed = parsed
|
|
|
|
self.skipped = skipped
|
|
|
|
self.virtuals = virtuals
|
|
|
|
self.masked = masked
|
|
|
|
self.errors = errors
|
|
|
|
self.sofar = cached + parsed
|
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class ParseProgress(OperationProgress):
|
2010-11-19 05:47:36 +00:00
|
|
|
"""Recipe parsing progress"""
|
2012-02-23 13:47:16 +00:00
|
|
|
def __init__(self, current, total):
|
|
|
|
OperationProgress.__init__(self, current, total, "Recipe parsing")
|
2010-11-19 05:47:36 +00:00
|
|
|
|
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class CacheLoadStarted(OperationStarted):
|
2010-11-22 15:13:56 +00:00
|
|
|
"""Loading of the dependency cache has begun"""
|
|
|
|
def __init__(self, total):
|
2012-02-23 13:47:16 +00:00
|
|
|
OperationStarted.__init__(self, "Loading cache Started")
|
2010-11-22 15:13:56 +00:00
|
|
|
self.total = total
|
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class CacheLoadProgress(OperationProgress):
|
2010-11-22 15:13:56 +00:00
|
|
|
"""Cache loading progress"""
|
2012-02-23 13:47:16 +00:00
|
|
|
def __init__(self, current, total):
|
|
|
|
OperationProgress.__init__(self, current, total, "Loading cache")
|
2010-11-22 15:13:56 +00:00
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class CacheLoadCompleted(OperationCompleted):
|
2010-11-22 15:13:56 +00:00
|
|
|
"""Cache loading is complete"""
|
|
|
|
def __init__(self, total, num_entries):
|
2012-02-23 13:47:16 +00:00
|
|
|
OperationCompleted.__init__(self, total, "Loading cache Completed")
|
2010-11-22 15:13:56 +00:00
|
|
|
self.num_entries = num_entries
|
|
|
|
|
2012-02-23 13:47:16 +00:00
|
|
|
class TreeDataPreparationStarted(OperationStarted):
|
|
|
|
"""Tree data preparation started"""
|
|
|
|
def __init__(self):
|
|
|
|
OperationStarted.__init__(self, "Preparing tree data Started")
|
|
|
|
|
|
|
|
class TreeDataPreparationProgress(OperationProgress):
|
|
|
|
"""Tree data preparation is in progress"""
|
|
|
|
def __init__(self, current, total):
|
|
|
|
OperationProgress.__init__(self, current, total, "Preparing tree data")
|
|
|
|
|
|
|
|
class TreeDataPreparationCompleted(OperationCompleted):
|
|
|
|
"""Tree data preparation completed"""
|
|
|
|
def __init__(self, total):
|
|
|
|
OperationCompleted.__init__(self, total, "Preparing tree data Completed")
|
2011-01-01 23:55:54 +00:00
|
|
|
|
2010-01-20 18:46:02 +00:00
|
|
|
class DepTreeGenerated(Event):
|
|
|
|
"""
|
|
|
|
Event when a dependency tree has been generated
|
|
|
|
"""
|
|
|
|
|
|
|
|
def __init__(self, depgraph):
|
|
|
|
Event.__init__(self)
|
|
|
|
self._depgraph = depgraph
|
2010-06-09 23:17:29 +00:00
|
|
|
|
2011-01-04 20:08:51 +00:00
|
|
|
class TargetsTreeGenerated(Event):
|
|
|
|
"""
|
|
|
|
Event when a set of buildable targets has been generated
|
|
|
|
"""
|
|
|
|
def __init__(self, model):
|
|
|
|
Event.__init__(self)
|
|
|
|
self._model = model
|
|
|
|
|
2015-06-07 07:07:13 +00:00
|
|
|
class ReachableStamps(Event):
|
|
|
|
"""
|
|
|
|
An event listing all stamps reachable after parsing
|
|
|
|
which the metadata may use to clean up stale data
|
|
|
|
"""
|
|
|
|
|
|
|
|
def __init__(self, stamps):
|
|
|
|
Event.__init__(self)
|
|
|
|
self.stamps = stamps
|
|
|
|
|
2011-07-01 06:02:52 +00:00
|
|
|
class FilesMatchingFound(Event):
|
|
|
|
"""
|
|
|
|
Event when a list of files matching the supplied pattern has
|
|
|
|
been generated
|
|
|
|
"""
|
|
|
|
def __init__(self, pattern, matches):
|
|
|
|
Event.__init__(self)
|
|
|
|
self._pattern = pattern
|
|
|
|
self._matches = matches
|
|
|
|
|
2012-01-06 09:02:28 +00:00
|
|
|
class CoreBaseFilesFound(Event):
|
|
|
|
"""
|
|
|
|
Event when a list of appropriate config files has been generated
|
|
|
|
"""
|
|
|
|
def __init__(self, paths):
|
|
|
|
Event.__init__(self)
|
|
|
|
self._paths = paths
|
|
|
|
|
2011-01-04 20:28:20 +00:00
|
|
|
class ConfigFilesFound(Event):
|
|
|
|
"""
|
|
|
|
Event when a list of appropriate config files has been generated
|
|
|
|
"""
|
|
|
|
def __init__(self, variable, values):
|
|
|
|
Event.__init__(self)
|
2011-01-13 18:30:02 +00:00
|
|
|
self._variable = variable
|
2011-01-04 20:28:20 +00:00
|
|
|
self._values = values
|
|
|
|
|
2011-07-01 06:02:51 +00:00
|
|
|
class ConfigFilePathFound(Event):
|
|
|
|
"""
|
|
|
|
Event when a path for a config file has been found
|
|
|
|
"""
|
|
|
|
def __init__(self, path):
|
|
|
|
Event.__init__(self)
|
|
|
|
self._path = path
|
|
|
|
|
2010-06-09 23:17:29 +00:00
|
|
|
class MsgBase(Event):
|
|
|
|
"""Base class for messages"""
|
|
|
|
|
|
|
|
def __init__(self, msg):
|
|
|
|
self._message = msg
|
|
|
|
Event.__init__(self)
|
|
|
|
|
|
|
|
class MsgDebug(MsgBase):
|
|
|
|
"""Debug Message"""
|
|
|
|
|
|
|
|
class MsgNote(MsgBase):
|
|
|
|
"""Note Message"""
|
|
|
|
|
|
|
|
class MsgWarn(MsgBase):
|
|
|
|
"""Warning Message"""
|
|
|
|
|
|
|
|
class MsgError(MsgBase):
|
|
|
|
"""Error Message"""
|
|
|
|
|
|
|
|
class MsgFatal(MsgBase):
|
|
|
|
"""Fatal Message"""
|
|
|
|
|
|
|
|
class MsgPlain(MsgBase):
|
|
|
|
"""General output"""
|
|
|
|
|
2012-09-17 22:43:49 +00:00
|
|
|
class LogExecTTY(Event):
|
|
|
|
"""Send event containing program to spawn on tty of the logger"""
|
|
|
|
def __init__(self, msg, prog, sleep_delay, retries):
|
|
|
|
Event.__init__(self)
|
|
|
|
self.msg = msg
|
|
|
|
self.prog = prog
|
|
|
|
self.sleep_delay = sleep_delay
|
|
|
|
self.retries = retries
|
|
|
|
|
2010-06-09 23:17:29 +00:00
|
|
|
class LogHandler(logging.Handler):
|
|
|
|
"""Dispatch logging messages as bitbake events"""
|
|
|
|
|
|
|
|
def emit(self, record):
|
2011-05-06 00:43:38 +00:00
|
|
|
if record.exc_info:
|
|
|
|
etype, value, tb = record.exc_info
|
|
|
|
if hasattr(tb, 'tb_next'):
|
|
|
|
tb = list(bb.exceptions.extract_traceback(tb, context=3))
|
2015-12-09 12:02:56 +00:00
|
|
|
# Need to turn the value into something the logging system can pickle
|
2011-05-06 00:43:38 +00:00
|
|
|
record.bb_exc_info = (etype, value, tb)
|
2016-05-12 07:05:32 +00:00
|
|
|
record.bb_exc_formatted = bb.exceptions.format_exception(etype, value, tb, limit=5)
|
|
|
|
value = str(value)
|
2011-05-06 00:43:38 +00:00
|
|
|
record.exc_info = None
|
2010-06-10 15:05:52 +00:00
|
|
|
fire(record, None)
|
2011-01-10 16:20:50 +00:00
|
|
|
|
|
|
|
def filter(self, record):
|
|
|
|
record.taskpid = worker_pid
|
|
|
|
return True
|
2012-02-23 13:47:15 +00:00
|
|
|
|
|
|
|
class RequestPackageInfo(Event):
|
|
|
|
"""
|
|
|
|
Event to request package information
|
|
|
|
"""
|
|
|
|
|
|
|
|
class PackageInfo(Event):
|
|
|
|
"""
|
|
|
|
Package information for GUI
|
|
|
|
"""
|
|
|
|
def __init__(self, pkginfolist):
|
|
|
|
Event.__init__(self)
|
|
|
|
self._pkginfolist = pkginfolist
|
2012-04-24 08:16:10 +00:00
|
|
|
|
2013-09-18 12:15:52 +00:00
|
|
|
class MetadataEvent(Event):
|
|
|
|
"""
|
|
|
|
Generic event that target for OE-Core classes
|
|
|
|
to report information during asynchrous execution
|
|
|
|
"""
|
|
|
|
def __init__(self, eventtype, eventdata):
|
|
|
|
Event.__init__(self)
|
|
|
|
self.type = eventtype
|
2014-07-18 11:07:22 +00:00
|
|
|
self._localdata = eventdata
|
2013-09-18 12:15:52 +00:00
|
|
|
|
2012-04-24 08:16:10 +00:00
|
|
|
class SanityCheck(Event):
|
|
|
|
"""
|
2014-08-20 12:23:27 +00:00
|
|
|
Event to run sanity checks, either raise errors or generate events as return status.
|
2012-04-24 08:16:10 +00:00
|
|
|
"""
|
2014-03-26 15:07:59 +00:00
|
|
|
def __init__(self, generateevents = True):
|
|
|
|
Event.__init__(self)
|
|
|
|
self.generateevents = generateevents
|
2012-04-24 08:16:10 +00:00
|
|
|
|
|
|
|
class SanityCheckPassed(Event):
|
|
|
|
"""
|
2014-08-20 12:23:27 +00:00
|
|
|
Event to indicate sanity check has passed
|
2012-04-24 08:16:10 +00:00
|
|
|
"""
|
2012-05-28 17:10:39 +00:00
|
|
|
|
|
|
|
class SanityCheckFailed(Event):
|
|
|
|
"""
|
|
|
|
Event to indicate sanity check has failed
|
|
|
|
"""
|
2012-09-26 13:59:57 +00:00
|
|
|
def __init__(self, msg, network_error=False):
|
2012-05-28 17:10:39 +00:00
|
|
|
Event.__init__(self)
|
|
|
|
self._msg = msg
|
2012-09-26 13:59:57 +00:00
|
|
|
self._network_error = network_error
|
2012-10-11 11:45:07 +00:00
|
|
|
|
|
|
|
class NetworkTest(Event):
|
|
|
|
"""
|
2014-03-26 15:07:59 +00:00
|
|
|
Event to run network connectivity tests, either raise errors or generate events as return status.
|
2012-10-11 11:45:07 +00:00
|
|
|
"""
|
2014-03-26 15:07:59 +00:00
|
|
|
def __init__(self, generateevents = True):
|
|
|
|
Event.__init__(self)
|
|
|
|
self.generateevents = generateevents
|
2012-10-11 11:45:07 +00:00
|
|
|
|
|
|
|
class NetworkTestPassed(Event):
|
|
|
|
"""
|
|
|
|
Event to indicate network test has passed
|
|
|
|
"""
|
|
|
|
|
|
|
|
class NetworkTestFailed(Event):
|
|
|
|
"""
|
|
|
|
Event to indicate network test has failed
|
|
|
|
"""
|
|
|
|
|