code.vuplus.com Git - vuplus_bitbake/blob - lib/bb/event.py

   1 #!/usr/bin/env python
   2 # ex:ts=4:sw=4:sts=4:et
   3 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
   4 """
   5 BitBake 'Event' implementation
   6
   7 Classes and functions for manipulating 'events' in the
   8 BitBake build tools.
   9
  10 Copyright (C) 2003, 2004  Chris Larson
  11
  12 This program is free software; you can redistribute it and/or modify it under
  13 the terms of the GNU General Public License as published by the Free Software
  14 Foundation; either version 2 of the License, or (at your option) any later
  15 version.
  16
  17 This program is distributed in the hope that it will be useful, but WITHOUT
  18 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  19 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License along with
  22 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  23 Place, Suite 330, Boston, MA 02111-1307 USA.
  24 """
  25
  26 import os, re
  27 import bb.data
  28 import bb.utils
  29
  30 class Event:
  31     """Base class for events"""
  32     type = "Event"
  33
  34     def __init__(self, d = bb.data.init()):
  35         self._data = d
  36
  37     def getData(self):
  38         return self._data
  39
  40     def setData(self, data):
  41         self._data = data
  42
  43     data = property(getData, setData, None, "data property")
  44
  45 NotHandled = 0
  46 Handled = 1
  47
  48 Registered        = 10
  49 AlreadyRegistered = 14
  50
  51 # Internal
  52 _handlers = []
  53 _handlers_dict = {}
  54
  55 def tmpHandler(event):
  56     """Default handler for code events"""
  57     return NotHandled
  58
  59 def defaultTmpHandler():
  60     tmp = "def tmpHandler(e):\n\t\"\"\"heh\"\"\"\n\treturn NotHandled"
  61     comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event.defaultTmpHandler")
  62     return comp
  63
  64 def fire(event):
  65     """Fire off an Event"""
  66     for h in _handlers:
  67         if type(h).__name__ == "code":
  68             exec(h)
  69             if tmpHandler(event) == Handled:
  70                 return Handled
  71         else:
  72             if h(event) == Handled:
  73                 return Handled
  74     return NotHandled
  75
  76 def register(name, handler):
  77     """Register an Event handler"""
  78
  79     # already registered
  80     if name in _handlers_dict:
  81         return AlreadyRegistered
  82
  83     if handler is not None:
  84 #       handle string containing python code
  85         if type(handler).__name__ == "str":
  86             _registerCode(handler)
  87         else:
  88             _handlers.append(handler)
  89
  90         _handlers_dict[name] = 1
  91         return Registered
  92
  93 def _registerCode(handlerStr):
  94     """Register a 'code' Event.
  95        Deprecated interface; call register instead.
  96
  97        Expects to be passed python code as a string, which will
  98        be passed in turn to compile() and then exec().  Note that
  99        the code will be within a function, so should have had
 100        appropriate tabbing put in place."""
 101     tmp = "def tmpHandler(e):\n%s" % handlerStr
 102     comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event._registerCode")
 103 #   prevent duplicate registration
 104     _handlers.append(comp)
 105
 106 def remove(name, handler):
 107     """Remove an Event handler"""
 108
 109     _handlers_dict.pop(name)
 110     if type(handler).__name__ == "str":
 111         return _removeCode(handler)
 112     else:
 113         _handlers.remove(handler)
 114
 115 def _removeCode(handlerStr):
 116     """Remove a 'code' Event handler
 117        Deprecated interface; call remove instead."""
 118     tmp = "def tmpHandler(e):\n%s" % handlerStr
 119     comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event._removeCode")
 120     _handlers.remove(comp)
 121
 122 def getName(e):
 123     """Returns the name of a class or class instance"""
 124     if getattr(e, "__name__", None) == None:
 125         return e.__class__.__name__
 126     else:
 127         return e.__name__
 128
 129
 130 class PkgBase(Event):
 131     """Base class for package events"""
 132
 133     def __init__(self, t, d = bb.data.init()):
 134         self._pkg = t
 135         Event.__init__(self, d)
 136
 137     def getPkg(self):
 138         return self._pkg
 139
 140     def setPkg(self, pkg):
 141         self._pkg = pkg
 142
 143     pkg = property(getPkg, setPkg, None, "pkg property")
 144
 145
 146 class BuildBase(Event):
 147     """Base class for bbmake run events"""
 148
 149     def __init__(self, n, p, c, failures = 0):
 150         self._name = n
 151         self._pkgs = p
 152         Event.__init__(self, c)
 153         self._failures = failures
 154
 155     def getPkgs(self):
 156         return self._pkgs
 157
 158     def setPkgs(self, pkgs):
 159         self._pkgs = pkgs
 160
 161     def getName(self):
 162         return self._name
 163
 164     def setName(self, name):
 165         self._name = name
 166
 167     def getCfg(self):
 168         return self.data
 169
 170     def setCfg(self, cfg):
 171         self.data = cfg
 172
 173     def getFailures(self):
 174         """
 175         Return the number of failed packages
 176         """
 177         return self._failures
 178
 179     pkgs = property(getPkgs, setPkgs, None, "pkgs property")
 180     name = property(getName, setName, None, "name property")
 181     cfg = property(getCfg, setCfg, None, "cfg property")
 182
 183
 184 class DepBase(PkgBase):
 185     """Base class for dependency events"""
 186
 187     def __init__(self, t, data, d):
 188         self._dep = d
 189         PkgBase.__init__(self, t, data)
 190
 191     def getDep(self):
 192         return self._dep
 193
 194     def setDep(self, dep):
 195         self._dep = dep
 196
 197     dep = property(getDep, setDep, None, "dep property")
 198
 199
 200 class PkgStarted(PkgBase):
 201     """Package build started"""
 202
 203
 204 class PkgFailed(PkgBase):
 205     """Package build failed"""
 206
 207
 208 class PkgSucceeded(PkgBase):
 209     """Package build completed"""
 210
 211
 212 class BuildStarted(BuildBase):
 213     """bbmake build run started"""
 214
 215
 216 class BuildCompleted(BuildBase):
 217     """bbmake build run completed"""
 218
 219
 220 class UnsatisfiedDep(DepBase):
 221     """Unsatisfied Dependency"""
 222
 223
 224 class RecursiveDep(DepBase):
 225     """Recursive Dependency"""
 226
 227 class NoProvider(Event):
 228     """No Provider for an Event"""
 229
 230     def __init__(self, item, data,runtime=False):
 231         Event.__init__(self, data)
 232         self._item = item
 233         self._runtime = runtime
 234
 235     def getItem(self):
 236         return self._item
 237
 238     def isRuntime(self):
 239         return self._runtime
 240
 241 class MultipleProviders(Event):
 242     """Multiple Providers"""
 243
 244     def  __init__(self, item, candidates, data, runtime = False):
 245         Event.__init__(self, data)
 246         self._item = item
 247         self._candidates = candidates
 248         self._is_runtime = runtime
 249
 250     def isRuntime(self):
 251         """
 252         Is this a runtime issue?
 253         """
 254         return self._is_runtime
 255
 256     def getItem(self):
 257         """
 258         The name for the to be build item
 259         """
 260         return self._item
 261
 262     def getCandidates(self):
 263         """
 264         Get the possible Candidates for a PROVIDER.
 265         """
 266         return self._candidates