forked from brl/citadel
841 lines
25 KiB
Python
841 lines
25 KiB
Python
|
# 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.
|
||
|
"""
|
||
|
|
||
|
# 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.
|
||
|
|
||
|
import os, sys
|
||
|
import warnings
|
||
|
import pickle
|
||
|
import logging
|
||
|
import atexit
|
||
|
import traceback
|
||
|
import ast
|
||
|
import threading
|
||
|
|
||
|
import bb.utils
|
||
|
import bb.compat
|
||
|
import bb.exceptions
|
||
|
|
||
|
# This is the pid for which we should generate the event. This is set when
|
||
|
# the runqueue forks off.
|
||
|
worker_pid = 0
|
||
|
worker_fire = None
|
||
|
|
||
|
logger = logging.getLogger('BitBake.Event')
|
||
|
|
||
|
class Event(object):
|
||
|
"""Base class for events"""
|
||
|
|
||
|
def __init__(self):
|
||
|
self.pid = worker_pid
|
||
|
|
||
|
|
||
|
class HeartbeatEvent(Event):
|
||
|
"""Triggered at regular time intervals of 10 seconds. Other events can fire much more often
|
||
|
(runQueueTaskStarted when there are many short tasks) or not at all for long periods
|
||
|
of time (again runQueueTaskStarted, when there is just one long-running task), so this
|
||
|
event is more suitable for doing some task-independent work occassionally."""
|
||
|
def __init__(self, time):
|
||
|
Event.__init__(self)
|
||
|
self.time = time
|
||
|
|
||
|
Registered = 10
|
||
|
AlreadyRegistered = 14
|
||
|
|
||
|
def get_class_handlers():
|
||
|
return _handlers
|
||
|
|
||
|
def set_class_handlers(h):
|
||
|
global _handlers
|
||
|
_handlers = h
|
||
|
|
||
|
def clean_class_handlers():
|
||
|
return bb.compat.OrderedDict()
|
||
|
|
||
|
# Internal
|
||
|
_handlers = clean_class_handlers()
|
||
|
_ui_handlers = {}
|
||
|
_ui_logfilters = {}
|
||
|
_ui_handler_seq = 0
|
||
|
_event_handler_map = {}
|
||
|
_catchall_handlers = {}
|
||
|
_eventfilter = None
|
||
|
_uiready = False
|
||
|
_thread_lock = threading.Lock()
|
||
|
_thread_lock_enabled = False
|
||
|
|
||
|
if hasattr(__builtins__, '__setitem__'):
|
||
|
builtins = __builtins__
|
||
|
else:
|
||
|
builtins = __builtins__.__dict__
|
||
|
|
||
|
def enable_threadlock():
|
||
|
global _thread_lock_enabled
|
||
|
_thread_lock_enabled = True
|
||
|
|
||
|
def disable_threadlock():
|
||
|
global _thread_lock_enabled
|
||
|
_thread_lock_enabled = False
|
||
|
|
||
|
def execute_handler(name, handler, event, d):
|
||
|
event.data = d
|
||
|
addedd = False
|
||
|
if 'd' not in builtins:
|
||
|
builtins['d'] = d
|
||
|
addedd = True
|
||
|
try:
|
||
|
ret = handler(event)
|
||
|
except (bb.parse.SkipRecipe, bb.BBHandledException):
|
||
|
raise
|
||
|
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
|
||
|
if addedd:
|
||
|
del builtins['d']
|
||
|
|
||
|
def fire_class_handlers(event, d):
|
||
|
if isinstance(event, logging.LogRecord):
|
||
|
return
|
||
|
|
||
|
eid = str(event.__class__)[8:-2]
|
||
|
evt_hmap = _event_handler_map.get(eid, {})
|
||
|
for name, handler in list(_handlers.items()):
|
||
|
if name in _catchall_handlers or name in evt_hmap:
|
||
|
if _eventfilter:
|
||
|
if not _eventfilter(name, handler, event, d):
|
||
|
continue
|
||
|
execute_handler(name, handler, event, d)
|
||
|
|
||
|
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")
|
||
|
if not _uiready:
|
||
|
from bb.msg import BBLogFormatter
|
||
|
stdout = logging.StreamHandler(sys.stdout)
|
||
|
stderr = logging.StreamHandler(sys.stderr)
|
||
|
formatter = BBLogFormatter("%(levelname)s: %(message)s")
|
||
|
stdout.setFormatter(formatter)
|
||
|
stderr.setFormatter(formatter)
|
||
|
|
||
|
# First check to see if we have any proper messages
|
||
|
msgprint = False
|
||
|
msgerrs = False
|
||
|
|
||
|
# Should we print to stderr?
|
||
|
for event in ui_queue[:]:
|
||
|
if isinstance(event, logging.LogRecord) and event.levelno >= logging.WARNING:
|
||
|
msgerrs = True
|
||
|
break
|
||
|
|
||
|
if msgerrs:
|
||
|
logger.addHandler(stderr)
|
||
|
else:
|
||
|
logger.addHandler(stdout)
|
||
|
|
||
|
for event in ui_queue[:]:
|
||
|
if isinstance(event, logging.LogRecord):
|
||
|
if event.levelno > logging.DEBUG:
|
||
|
logger.handle(event)
|
||
|
msgprint = True
|
||
|
|
||
|
# Nope, so just print all of the messages we have (including debug messages)
|
||
|
if not msgprint:
|
||
|
for event in ui_queue[:]:
|
||
|
if isinstance(event, logging.LogRecord):
|
||
|
logger.handle(event)
|
||
|
if msgerrs:
|
||
|
logger.removeHandler(stderr)
|
||
|
else:
|
||
|
logger.removeHandler(stdout)
|
||
|
|
||
|
def fire_ui_handlers(event, d):
|
||
|
global _thread_lock
|
||
|
global _thread_lock_enabled
|
||
|
|
||
|
if not _uiready:
|
||
|
# No UI handlers registered yet, queue up the messages
|
||
|
ui_queue.append(event)
|
||
|
return
|
||
|
|
||
|
if _thread_lock_enabled:
|
||
|
_thread_lock.acquire()
|
||
|
|
||
|
errors = []
|
||
|
for h in _ui_handlers:
|
||
|
#print "Sending event %s" % event
|
||
|
try:
|
||
|
if not _ui_logfilters[h].filter(event):
|
||
|
continue
|
||
|
# We use pickle here since it better handles object instances
|
||
|
# which xmlrpc's marshaller does not. Events *must* be serializable
|
||
|
# by pickle.
|
||
|
if hasattr(_ui_handlers[h].event, "sendpickle"):
|
||
|
_ui_handlers[h].event.sendpickle((pickle.dumps(event)))
|
||
|
else:
|
||
|
_ui_handlers[h].event.send(event)
|
||
|
except:
|
||
|
errors.append(h)
|
||
|
for h in errors:
|
||
|
del _ui_handlers[h]
|
||
|
|
||
|
if _thread_lock_enabled:
|
||
|
_thread_lock.release()
|
||
|
|
||
|
def fire(event, d):
|
||
|
"""Fire off an Event"""
|
||
|
|
||
|
# We can fire class handlers in the worker process context and this is
|
||
|
# desired so they get the task based datastore.
|
||
|
# UI handlers need to be fired in the server context so we defer this. They
|
||
|
# don't have a datastore so the datastore context isn't a problem.
|
||
|
|
||
|
fire_class_handlers(event, d)
|
||
|
if worker_fire:
|
||
|
worker_fire(event, d)
|
||
|
else:
|
||
|
# If messages have been queued up, clear the queue
|
||
|
global _uiready, ui_queue
|
||
|
if _uiready and ui_queue:
|
||
|
for queue_event in ui_queue:
|
||
|
fire_ui_handlers(queue_event, d)
|
||
|
ui_queue = []
|
||
|
fire_ui_handlers(event, d)
|
||
|
|
||
|
def fire_from_worker(event, d):
|
||
|
fire_ui_handlers(event, d)
|
||
|
|
||
|
noop = lambda _: None
|
||
|
def register(name, handler, mask=None, filename=None, lineno=None):
|
||
|
"""Register an Event handler"""
|
||
|
|
||
|
# already registered
|
||
|
if name in _handlers:
|
||
|
return AlreadyRegistered
|
||
|
|
||
|
if handler is not None:
|
||
|
# handle string containing python code
|
||
|
if isinstance(handler, str):
|
||
|
tmp = "def %s(e):\n%s" % (name, handler)
|
||
|
try:
|
||
|
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)
|
||
|
except SyntaxError:
|
||
|
logger.error("Unable to register event handler '%s':\n%s", name,
|
||
|
''.join(traceback.format_exc(limit=0)))
|
||
|
_handlers[name] = noop
|
||
|
return
|
||
|
env = {}
|
||
|
bb.utils.better_exec(code, env)
|
||
|
func = bb.utils.better_eval(name, env)
|
||
|
_handlers[name] = func
|
||
|
else:
|
||
|
_handlers[name] = handler
|
||
|
|
||
|
if not mask or '*' in mask:
|
||
|
_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
|
||
|
|
||
|
return Registered
|
||
|
|
||
|
def remove(name, handler):
|
||
|
"""Remove an Event handler"""
|
||
|
_handlers.pop(name)
|
||
|
if name in _catchall_handlers:
|
||
|
_catchall_handlers.pop(name)
|
||
|
for event in _event_handler_map.keys():
|
||
|
if name in _event_handler_map[event]:
|
||
|
_event_handler_map[event].pop(name)
|
||
|
|
||
|
def get_handlers():
|
||
|
return _handlers
|
||
|
|
||
|
def set_handlers(handlers):
|
||
|
global _handlers
|
||
|
_handlers = handlers
|
||
|
|
||
|
def set_eventfilter(func):
|
||
|
global _eventfilter
|
||
|
_eventfilter = func
|
||
|
|
||
|
def register_UIHhandler(handler, mainui=False):
|
||
|
bb.event._ui_handler_seq = bb.event._ui_handler_seq + 1
|
||
|
_ui_handlers[_ui_handler_seq] = handler
|
||
|
level, debug_domains = bb.msg.constructLogOptions()
|
||
|
_ui_logfilters[_ui_handler_seq] = UIEventFilter(level, debug_domains)
|
||
|
if mainui:
|
||
|
global _uiready
|
||
|
_uiready = _ui_handler_seq
|
||
|
return _ui_handler_seq
|
||
|
|
||
|
def unregister_UIHhandler(handlerNum, mainui=False):
|
||
|
if mainui:
|
||
|
global _uiready
|
||
|
_uiready = False
|
||
|
if handlerNum in _ui_handlers:
|
||
|
del _ui_handlers[handlerNum]
|
||
|
return
|
||
|
|
||
|
def get_uihandler():
|
||
|
if _uiready is False:
|
||
|
return None
|
||
|
return _uiready
|
||
|
|
||
|
# 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):
|
||
|
self.eventmask = eventmask
|
||
|
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
|
||
|
eid = str(event.__class__)[8:-2]
|
||
|
if self.eventmask and eid not in self.eventmask:
|
||
|
return False
|
||
|
return True
|
||
|
|
||
|
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
|
||
|
|
||
|
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__
|
||
|
|
||
|
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);
|
||
|
|
||
|
class ConfigParsed(Event):
|
||
|
"""Configuration Parsing Complete"""
|
||
|
|
||
|
class MultiConfigParsed(Event):
|
||
|
"""Multi-Config Parsing Complete"""
|
||
|
def __init__(self, mcdata):
|
||
|
self.mcdata = mcdata
|
||
|
Event.__init__(self)
|
||
|
|
||
|
class RecipeEvent(Event):
|
||
|
def __init__(self, fn):
|
||
|
self.fn = fn
|
||
|
Event.__init__(self)
|
||
|
|
||
|
class RecipePreFinalise(RecipeEvent):
|
||
|
""" Recipe Parsing Complete but not yet finialised"""
|
||
|
|
||
|
class RecipeTaskPreProcess(RecipeEvent):
|
||
|
"""
|
||
|
Recipe Tasks about to be finalised
|
||
|
The list of tasks should be final at this point and handlers
|
||
|
are only able to change interdependencies
|
||
|
"""
|
||
|
def __init__(self, fn, tasklist):
|
||
|
self.fn = fn
|
||
|
self.tasklist = tasklist
|
||
|
Event.__init__(self)
|
||
|
|
||
|
class RecipeParsed(RecipeEvent):
|
||
|
""" Recipe Parsing Complete """
|
||
|
|
||
|
class StampUpdate(Event):
|
||
|
"""Trigger for any adjustment of the stamp files to happen"""
|
||
|
|
||
|
def __init__(self, targets, stampfns):
|
||
|
self._targets = targets
|
||
|
self._stampfns = stampfns
|
||
|
Event.__init__(self)
|
||
|
|
||
|
def getStampPrefix(self):
|
||
|
return self._stampfns
|
||
|
|
||
|
def getTargets(self):
|
||
|
return self._targets
|
||
|
|
||
|
stampPrefix = property(getStampPrefix)
|
||
|
targets = property(getTargets)
|
||
|
|
||
|
class BuildBase(Event):
|
||
|
"""Base class for bitbake build events"""
|
||
|
|
||
|
def __init__(self, n, p, failures = 0):
|
||
|
self._name = n
|
||
|
self._pkgs = p
|
||
|
Event.__init__(self)
|
||
|
self._failures = failures
|
||
|
|
||
|
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
|
||
|
|
||
|
def getFailures(self):
|
||
|
"""
|
||
|
Return the number of failed packages
|
||
|
"""
|
||
|
return self._failures
|
||
|
|
||
|
pkgs = property(getPkgs, setPkgs, None, "pkgs property")
|
||
|
name = property(getName, setName, None, "name property")
|
||
|
cfg = property(getCfg, setCfg, None, "cfg property")
|
||
|
|
||
|
|
||
|
|
||
|
class BuildInit(BuildBase):
|
||
|
"""buildFile or buildTargets was invoked"""
|
||
|
def __init__(self, p=[]):
|
||
|
name = None
|
||
|
BuildBase.__init__(self, name, p)
|
||
|
|
||
|
class BuildStarted(BuildBase, OperationStarted):
|
||
|
"""Event when builds start"""
|
||
|
def __init__(self, n, p, failures = 0):
|
||
|
OperationStarted.__init__(self, "Building Started")
|
||
|
BuildBase.__init__(self, n, p, failures)
|
||
|
|
||
|
class BuildCompleted(BuildBase, OperationCompleted):
|
||
|
"""Event when builds have completed"""
|
||
|
def __init__(self, total, n, p, failures=0, interrupted=0):
|
||
|
if not failures:
|
||
|
OperationCompleted.__init__(self, total, "Building Succeeded")
|
||
|
else:
|
||
|
OperationCompleted.__init__(self, total, "Building Failed")
|
||
|
self._interrupted = interrupted
|
||
|
BuildBase.__init__(self, n, p, failures)
|
||
|
|
||
|
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
|
||
|
|
||
|
class DiskUsageSample:
|
||
|
def __init__(self, available_bytes, free_bytes, total_bytes):
|
||
|
# Number of bytes available to non-root processes.
|
||
|
self.available_bytes = available_bytes
|
||
|
# Number of bytes available to root processes.
|
||
|
self.free_bytes = free_bytes
|
||
|
# Total capacity of the volume.
|
||
|
self.total_bytes = total_bytes
|
||
|
|
||
|
class MonitorDiskEvent(Event):
|
||
|
"""If BB_DISKMON_DIRS is set, then this event gets triggered each time disk space is checked.
|
||
|
Provides information about devices that are getting monitored."""
|
||
|
def __init__(self, disk_usage):
|
||
|
Event.__init__(self)
|
||
|
# hash of device root path -> DiskUsageSample
|
||
|
self.disk_usage = disk_usage
|
||
|
|
||
|
class NoProvider(Event):
|
||
|
"""No Provider for an Event"""
|
||
|
|
||
|
def __init__(self, item, runtime=False, dependees=None, reasons=None, close_matches=None):
|
||
|
Event.__init__(self)
|
||
|
self._item = item
|
||
|
self._runtime = runtime
|
||
|
self._dependees = dependees
|
||
|
self._reasons = reasons
|
||
|
self._close_matches = close_matches
|
||
|
|
||
|
def getItem(self):
|
||
|
return self._item
|
||
|
|
||
|
def isRuntime(self):
|
||
|
return self._runtime
|
||
|
|
||
|
def __str__(self):
|
||
|
msg = ''
|
||
|
if self._runtime:
|
||
|
r = "R"
|
||
|
else:
|
||
|
r = ""
|
||
|
|
||
|
extra = ''
|
||
|
if not self._reasons:
|
||
|
if self._close_matches:
|
||
|
extra = ". Close matches:\n %s" % '\n '.join(self._close_matches)
|
||
|
|
||
|
if self._dependees:
|
||
|
msg = "Nothing %sPROVIDES '%s' (but %s %sDEPENDS on or otherwise requires it)%s" % (r, self._item, ", ".join(self._dependees), r, extra)
|
||
|
else:
|
||
|
msg = "Nothing %sPROVIDES '%s'%s" % (r, self._item, extra)
|
||
|
if self._reasons:
|
||
|
for reason in self._reasons:
|
||
|
msg += '\n' + reason
|
||
|
return msg
|
||
|
|
||
|
|
||
|
class MultipleProviders(Event):
|
||
|
"""Multiple Providers"""
|
||
|
|
||
|
def __init__(self, item, candidates, runtime = False):
|
||
|
Event.__init__(self)
|
||
|
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
|
||
|
|
||
|
def __str__(self):
|
||
|
msg = "Multiple providers are available for %s%s (%s)" % (self._is_runtime and "runtime " or "",
|
||
|
self._item,
|
||
|
", ".join(self._candidates))
|
||
|
rtime = ""
|
||
|
if self._is_runtime:
|
||
|
rtime = "R"
|
||
|
msg += "\nConsider defining a PREFERRED_%sPROVIDER entry to match %s" % (rtime, self._item)
|
||
|
return msg
|
||
|
|
||
|
class ParseStarted(OperationStarted):
|
||
|
"""Recipe parsing for the runqueue has begun"""
|
||
|
def __init__(self, total):
|
||
|
OperationStarted.__init__(self, "Recipe parsing Started")
|
||
|
self.total = total
|
||
|
|
||
|
class ParseCompleted(OperationCompleted):
|
||
|
"""Recipe parsing for the runqueue has completed"""
|
||
|
def __init__(self, cached, parsed, skipped, masked, virtuals, errors, total):
|
||
|
OperationCompleted.__init__(self, total, "Recipe parsing Completed")
|
||
|
self.cached = cached
|
||
|
self.parsed = parsed
|
||
|
self.skipped = skipped
|
||
|
self.virtuals = virtuals
|
||
|
self.masked = masked
|
||
|
self.errors = errors
|
||
|
self.sofar = cached + parsed
|
||
|
|
||
|
class ParseProgress(OperationProgress):
|
||
|
"""Recipe parsing progress"""
|
||
|
def __init__(self, current, total):
|
||
|
OperationProgress.__init__(self, current, total, "Recipe parsing")
|
||
|
|
||
|
|
||
|
class CacheLoadStarted(OperationStarted):
|
||
|
"""Loading of the dependency cache has begun"""
|
||
|
def __init__(self, total):
|
||
|
OperationStarted.__init__(self, "Loading cache Started")
|
||
|
self.total = total
|
||
|
|
||
|
class CacheLoadProgress(OperationProgress):
|
||
|
"""Cache loading progress"""
|
||
|
def __init__(self, current, total):
|
||
|
OperationProgress.__init__(self, current, total, "Loading cache")
|
||
|
|
||
|
class CacheLoadCompleted(OperationCompleted):
|
||
|
"""Cache loading is complete"""
|
||
|
def __init__(self, total, num_entries):
|
||
|
OperationCompleted.__init__(self, total, "Loading cache Completed")
|
||
|
self.num_entries = num_entries
|
||
|
|
||
|
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")
|
||
|
|
||
|
class DepTreeGenerated(Event):
|
||
|
"""
|
||
|
Event when a dependency tree has been generated
|
||
|
"""
|
||
|
|
||
|
def __init__(self, depgraph):
|
||
|
Event.__init__(self)
|
||
|
self._depgraph = depgraph
|
||
|
|
||
|
class TargetsTreeGenerated(Event):
|
||
|
"""
|
||
|
Event when a set of buildable targets has been generated
|
||
|
"""
|
||
|
def __init__(self, model):
|
||
|
Event.__init__(self)
|
||
|
self._model = model
|
||
|
|
||
|
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
|
||
|
|
||
|
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
|
||
|
|
||
|
class ConfigFilesFound(Event):
|
||
|
"""
|
||
|
Event when a list of appropriate config files has been generated
|
||
|
"""
|
||
|
def __init__(self, variable, values):
|
||
|
Event.__init__(self)
|
||
|
self._variable = variable
|
||
|
self._values = values
|
||
|
|
||
|
class ConfigFilePathFound(Event):
|
||
|
"""
|
||
|
Event when a path for a config file has been found
|
||
|
"""
|
||
|
def __init__(self, path):
|
||
|
Event.__init__(self)
|
||
|
self._path = path
|
||
|
|
||
|
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"""
|
||
|
|
||
|
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
|
||
|
|
||
|
class LogHandler(logging.Handler):
|
||
|
"""Dispatch logging messages as bitbake events"""
|
||
|
|
||
|
def emit(self, record):
|
||
|
if record.exc_info:
|
||
|
etype, value, tb = record.exc_info
|
||
|
if hasattr(tb, 'tb_next'):
|
||
|
tb = list(bb.exceptions.extract_traceback(tb, context=3))
|
||
|
# Need to turn the value into something the logging system can pickle
|
||
|
record.bb_exc_info = (etype, value, tb)
|
||
|
record.bb_exc_formatted = bb.exceptions.format_exception(etype, value, tb, limit=5)
|
||
|
value = str(value)
|
||
|
record.exc_info = None
|
||
|
fire(record, None)
|
||
|
|
||
|
def filter(self, record):
|
||
|
record.taskpid = worker_pid
|
||
|
return True
|
||
|
|
||
|
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
|
||
|
self._localdata = eventdata
|
||
|
|
||
|
class ProcessStarted(Event):
|
||
|
"""
|
||
|
Generic process started event (usually part of the initial startup)
|
||
|
where further progress events will be delivered
|
||
|
"""
|
||
|
def __init__(self, processname, total):
|
||
|
Event.__init__(self)
|
||
|
self.processname = processname
|
||
|
self.total = total
|
||
|
|
||
|
class ProcessProgress(Event):
|
||
|
"""
|
||
|
Generic process progress event (usually part of the initial startup)
|
||
|
"""
|
||
|
def __init__(self, processname, progress):
|
||
|
Event.__init__(self)
|
||
|
self.processname = processname
|
||
|
self.progress = progress
|
||
|
|
||
|
class ProcessFinished(Event):
|
||
|
"""
|
||
|
Generic process finished event (usually part of the initial startup)
|
||
|
"""
|
||
|
def __init__(self, processname):
|
||
|
Event.__init__(self)
|
||
|
self.processname = processname
|
||
|
|
||
|
class SanityCheck(Event):
|
||
|
"""
|
||
|
Event to run sanity checks, either raise errors or generate events as return status.
|
||
|
"""
|
||
|
def __init__(self, generateevents = True):
|
||
|
Event.__init__(self)
|
||
|
self.generateevents = generateevents
|
||
|
|
||
|
class SanityCheckPassed(Event):
|
||
|
"""
|
||
|
Event to indicate sanity check has passed
|
||
|
"""
|
||
|
|
||
|
class SanityCheckFailed(Event):
|
||
|
"""
|
||
|
Event to indicate sanity check has failed
|
||
|
"""
|
||
|
def __init__(self, msg, network_error=False):
|
||
|
Event.__init__(self)
|
||
|
self._msg = msg
|
||
|
self._network_error = network_error
|
||
|
|
||
|
class NetworkTest(Event):
|
||
|
"""
|
||
|
Event to run network connectivity tests, either raise errors or generate events as return status.
|
||
|
"""
|
||
|
def __init__(self, generateevents = True):
|
||
|
Event.__init__(self)
|
||
|
self.generateevents = generateevents
|
||
|
|
||
|
class NetworkTestPassed(Event):
|
||
|
"""
|
||
|
Event to indicate network test has passed
|
||
|
"""
|
||
|
|
||
|
class NetworkTestFailed(Event):
|
||
|
"""
|
||
|
Event to indicate network test has failed
|
||
|
"""
|
||
|
|
||
|
class FindSigInfoResult(Event):
|
||
|
"""
|
||
|
Event to return results from findSigInfo command
|
||
|
"""
|
||
|
def __init__(self, result):
|
||
|
Event.__init__(self)
|
||
|
self.result = result
|