| OLD | NEW |
|---|
| (Empty) |
| 1 | |
| 2 from twisted.internet import gtk2reactor | |
| 3 gtk2reactor.install() | |
| 4 | |
| 5 import sys, time | |
| 6 | |
| 7 import pygtk | |
| 8 pygtk.require("2.0") | |
| 9 import gobject, gtk | |
| 10 assert(gtk.Window) # in gtk1 it's gtk.GtkWindow | |
| 11 | |
| 12 from twisted.spread import pb | |
| 13 | |
| 14 #from buildbot.clients.base import Builder, Client | |
| 15 from buildbot.clients.base import TextClient | |
| 16 from buildbot.util import now | |
| 17 | |
| 18 from buildbot.status.builder import SUCCESS, WARNINGS, FAILURE, EXCEPTION | |
| 19 | |
| 20 ''' | |
| 21 class Pane: | |
| 22 def __init__(self): | |
| 23 pass | |
| 24 | |
| 25 class OneRow(Pane): | |
| 26 """This is a one-row status bar. It has one square per Builder, and that | |
| 27 square is either red, yellow, or green. """ | |
| 28 | |
| 29 def __init__(self): | |
| 30 Pane.__init__(self) | |
| 31 self.widget = gtk.VBox(gtk.FALSE, 2) | |
| 32 self.nameBox = gtk.HBox(gtk.TRUE) | |
| 33 self.statusBox = gtk.HBox(gtk.TRUE) | |
| 34 self.widget.add(self.nameBox) | |
| 35 self.widget.add(self.statusBox) | |
| 36 self.widget.show_all() | |
| 37 self.builders = [] | |
| 38 | |
| 39 def getWidget(self): | |
| 40 return self.widget | |
| 41 def addBuilder(self, builder): | |
| 42 print "OneRow.addBuilder" | |
| 43 # todo: ordering. Should follow the order in which they were added | |
| 44 # to the original BotMaster | |
| 45 self.builders.append(builder) | |
| 46 # add the name to the left column, and a label (with background) to | |
| 47 # the right | |
| 48 name = gtk.Label(builder.name) | |
| 49 status = gtk.Label('??') | |
| 50 status.set_size_request(64,64) | |
| 51 box = gtk.EventBox() | |
| 52 box.add(status) | |
| 53 name.show() | |
| 54 box.show_all() | |
| 55 self.nameBox.add(name) | |
| 56 self.statusBox.add(box) | |
| 57 builder.haveSomeWidgets([name, status, box]) | |
| 58 | |
| 59 class R2Builder(Builder): | |
| 60 def start(self): | |
| 61 self.nameSquare.set_text(self.name) | |
| 62 self.statusSquare.set_text("???") | |
| 63 self.subscribe() | |
| 64 def haveSomeWidgets(self, widgets): | |
| 65 self.nameSquare, self.statusSquare, self.statusBox = widgets | |
| 66 | |
| 67 def remote_newLastBuildStatus(self, event): | |
| 68 color = None | |
| 69 if event: | |
| 70 text = "\n".join(event.text) | |
| 71 color = event.color | |
| 72 else: | |
| 73 text = "none" | |
| 74 self.statusSquare.set_text(text) | |
| 75 if color: | |
| 76 print "color", color | |
| 77 self.statusBox.modify_bg(gtk.STATE_NORMAL, | |
| 78 gtk.gdk.color_parse(color)) | |
| 79 | |
| 80 def remote_currentlyOffline(self): | |
| 81 self.statusSquare.set_text("offline") | |
| 82 def remote_currentlyIdle(self): | |
| 83 self.statusSquare.set_text("idle") | |
| 84 def remote_currentlyWaiting(self, seconds): | |
| 85 self.statusSquare.set_text("waiting") | |
| 86 def remote_currentlyInterlocked(self): | |
| 87 self.statusSquare.set_text("interlocked") | |
| 88 def remote_currentlyBuilding(self, eta): | |
| 89 self.statusSquare.set_text("building") | |
| 90 | |
| 91 | |
| 92 class CompactRow(Pane): | |
| 93 def __init__(self): | |
| 94 Pane.__init__(self) | |
| 95 self.widget = gtk.VBox(gtk.FALSE, 3) | |
| 96 self.nameBox = gtk.HBox(gtk.TRUE, 2) | |
| 97 self.lastBuildBox = gtk.HBox(gtk.TRUE, 2) | |
| 98 self.statusBox = gtk.HBox(gtk.TRUE, 2) | |
| 99 self.widget.add(self.nameBox) | |
| 100 self.widget.add(self.lastBuildBox) | |
| 101 self.widget.add(self.statusBox) | |
| 102 self.widget.show_all() | |
| 103 self.builders = [] | |
| 104 | |
| 105 def getWidget(self): | |
| 106 return self.widget | |
| 107 | |
| 108 def addBuilder(self, builder): | |
| 109 self.builders.append(builder) | |
| 110 | |
| 111 name = gtk.Label(builder.name) | |
| 112 name.show() | |
| 113 self.nameBox.add(name) | |
| 114 | |
| 115 last = gtk.Label('??') | |
| 116 last.set_size_request(64,64) | |
| 117 lastbox = gtk.EventBox() | |
| 118 lastbox.add(last) | |
| 119 lastbox.show_all() | |
| 120 self.lastBuildBox.add(lastbox) | |
| 121 | |
| 122 status = gtk.Label('??') | |
| 123 status.set_size_request(64,64) | |
| 124 statusbox = gtk.EventBox() | |
| 125 statusbox.add(status) | |
| 126 statusbox.show_all() | |
| 127 self.statusBox.add(statusbox) | |
| 128 | |
| 129 builder.haveSomeWidgets([name, last, lastbox, status, statusbox]) | |
| 130 | |
| 131 def removeBuilder(self, name, builder): | |
| 132 self.nameBox.remove(builder.nameSquare) | |
| 133 self.lastBuildBox.remove(builder.lastBuildBox) | |
| 134 self.statusBox.remove(builder.statusBox) | |
| 135 self.builders.remove(builder) | |
| 136 | |
| 137 class CompactBuilder(Builder): | |
| 138 def setup(self): | |
| 139 self.timer = None | |
| 140 self.text = [] | |
| 141 self.eta = None | |
| 142 def start(self): | |
| 143 self.nameSquare.set_text(self.name) | |
| 144 self.statusSquare.set_text("???") | |
| 145 self.subscribe() | |
| 146 def haveSomeWidgets(self, widgets): | |
| 147 (self.nameSquare, | |
| 148 self.lastBuildSquare, self.lastBuildBox, | |
| 149 self.statusSquare, self.statusBox) = widgets | |
| 150 | |
| 151 def remote_currentlyOffline(self): | |
| 152 self.eta = None | |
| 153 self.stopTimer() | |
| 154 self.statusSquare.set_text("offline") | |
| 155 self.statusBox.modify_bg(gtk.STATE_NORMAL, | |
| 156 gtk.gdk.color_parse("red")) | |
| 157 def remote_currentlyIdle(self): | |
| 158 self.eta = None | |
| 159 self.stopTimer() | |
| 160 self.statusSquare.set_text("idle") | |
| 161 def remote_currentlyWaiting(self, seconds): | |
| 162 self.nextBuild = now() + seconds | |
| 163 self.startTimer(self.updateWaiting) | |
| 164 def remote_currentlyInterlocked(self): | |
| 165 self.stopTimer() | |
| 166 self.statusSquare.set_text("interlocked") | |
| 167 def startTimer(self, func): | |
| 168 # the func must clear self.timer and return gtk.FALSE when the event | |
| 169 # has arrived | |
| 170 self.stopTimer() | |
| 171 self.timer = gtk.timeout_add(1000, func) | |
| 172 func() | |
| 173 def stopTimer(self): | |
| 174 if self.timer: | |
| 175 gtk.timeout_remove(self.timer) | |
| 176 self.timer = None | |
| 177 def updateWaiting(self): | |
| 178 when = self.nextBuild | |
| 179 if now() < when: | |
| 180 next = time.strftime("%H:%M:%S", time.localtime(when)) | |
| 181 secs = "[%d seconds]" % (when - now()) | |
| 182 self.statusSquare.set_text("waiting\n%s\n%s" % (next, secs)) | |
| 183 return gtk.TRUE # restart timer | |
| 184 else: | |
| 185 # done | |
| 186 self.statusSquare.set_text("waiting\n[RSN]") | |
| 187 self.timer = None | |
| 188 return gtk.FALSE | |
| 189 | |
| 190 def remote_currentlyBuilding(self, eta): | |
| 191 self.stopTimer() | |
| 192 self.statusSquare.set_text("building") | |
| 193 if eta: | |
| 194 d = eta.callRemote("subscribe", self, 5) | |
| 195 | |
| 196 def remote_newLastBuildStatus(self, event): | |
| 197 color = None | |
| 198 if event: | |
| 199 text = "\n".join(event.text) | |
| 200 color = event.color | |
| 201 else: | |
| 202 text = "none" | |
| 203 if not color: color = "gray" | |
| 204 self.lastBuildSquare.set_text(text) | |
| 205 self.lastBuildBox.modify_bg(gtk.STATE_NORMAL, | |
| 206 gtk.gdk.color_parse(color)) | |
| 207 | |
| 208 def remote_newEvent(self, event): | |
| 209 assert(event.__class__ == GtkUpdatingEvent) | |
| 210 self.current = event | |
| 211 event.builder = self | |
| 212 self.text = event.text | |
| 213 if not self.text: self.text = ["idle"] | |
| 214 self.eta = None | |
| 215 self.stopTimer() | |
| 216 self.updateText() | |
| 217 color = event.color | |
| 218 if not color: color = "gray" | |
| 219 self.statusBox.modify_bg(gtk.STATE_NORMAL, | |
| 220 gtk.gdk.color_parse(color)) | |
| 221 | |
| 222 def updateCurrent(self): | |
| 223 text = self.current.text | |
| 224 if text: | |
| 225 self.text = text | |
| 226 self.updateText() | |
| 227 color = self.current.color | |
| 228 if color: | |
| 229 self.statusBox.modify_bg(gtk.STATE_NORMAL, | |
| 230 gtk.gdk.color_parse(color)) | |
| 231 def updateText(self): | |
| 232 etatext = [] | |
| 233 if self.eta: | |
| 234 etatext = [time.strftime("%H:%M:%S", time.localtime(self.eta))] | |
| 235 if now() > self.eta: | |
| 236 etatext += ["RSN"] | |
| 237 else: | |
| 238 seconds = self.eta - now() | |
| 239 etatext += ["[%d secs]" % seconds] | |
| 240 text = "\n".join(self.text + etatext) | |
| 241 self.statusSquare.set_text(text) | |
| 242 def updateTextTimer(self): | |
| 243 self.updateText() | |
| 244 return gtk.TRUE # restart timer | |
| 245 | |
| 246 def remote_progress(self, seconds): | |
| 247 if seconds == None: | |
| 248 self.eta = None | |
| 249 else: | |
| 250 self.eta = now() + seconds | |
| 251 self.startTimer(self.updateTextTimer) | |
| 252 self.updateText() | |
| 253 def remote_finished(self, eta): | |
| 254 self.eta = None | |
| 255 self.stopTimer() | |
| 256 self.updateText() | |
| 257 eta.callRemote("unsubscribe", self) | |
| 258 ''' | |
| 259 | |
| 260 class Box: | |
| 261 def __init__(self, text="?"): | |
| 262 self.text = text | |
| 263 self.box = gtk.EventBox() | |
| 264 self.label = gtk.Label(text) | |
| 265 self.box.add(self.label) | |
| 266 self.box.set_size_request(64,64) | |
| 267 self.timer = None | |
| 268 | |
| 269 def getBox(self): | |
| 270 return self.box | |
| 271 | |
| 272 def setText(self, text): | |
| 273 self.text = text | |
| 274 self.label.set_text(text) | |
| 275 | |
| 276 def setColor(self, color): | |
| 277 if not color: | |
| 278 return | |
| 279 self.box.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(color)) | |
| 280 | |
| 281 def setETA(self, eta): | |
| 282 if eta: | |
| 283 self.when = now() + eta | |
| 284 self.startTimer() | |
| 285 else: | |
| 286 self.stopTimer() | |
| 287 | |
| 288 def startTimer(self): | |
| 289 self.stopTimer() | |
| 290 self.timer = gobject.timeout_add(1000, self.update) | |
| 291 self.update() | |
| 292 | |
| 293 def stopTimer(self): | |
| 294 if self.timer: | |
| 295 gobject.source_remove(self.timer) | |
| 296 self.timer = None | |
| 297 self.label.set_text(self.text) | |
| 298 | |
| 299 def update(self): | |
| 300 if now() < self.when: | |
| 301 next = time.strftime("%H:%M:%S", time.localtime(self.when)) | |
| 302 secs = "[%d secs]" % (self.when - now()) | |
| 303 self.label.set_text("%s\n%s\n%s" % (self.text, next, secs)) | |
| 304 return True # restart timer | |
| 305 else: | |
| 306 # done | |
| 307 self.label.set_text("%s\n[soon]\n[overdue]" % (self.text,)) | |
| 308 self.timer = None | |
| 309 return False | |
| 310 | |
| 311 | |
| 312 | |
| 313 class ThreeRowBuilder: | |
| 314 def __init__(self, name, ref): | |
| 315 self.name = name | |
| 316 | |
| 317 self.last = Box() | |
| 318 self.current = Box() | |
| 319 self.step = Box("idle") | |
| 320 self.step.setColor("white") | |
| 321 | |
| 322 self.ref = ref | |
| 323 | |
| 324 def getBoxes(self): | |
| 325 return self.last.getBox(), self.current.getBox(), self.step.getBox() | |
| 326 | |
| 327 def getLastBuild(self): | |
| 328 d = self.ref.callRemote("getLastFinishedBuild") | |
| 329 d.addCallback(self.gotLastBuild) | |
| 330 def gotLastBuild(self, build): | |
| 331 if build: | |
| 332 build.callRemote("getText").addCallback(self.gotLastText) | |
| 333 build.callRemote("getResults").addCallback(self.gotLastResult) | |
| 334 | |
| 335 def gotLastText(self, text): | |
| 336 print "Got text", text | |
| 337 self.last.setText("\n".join(text)) | |
| 338 | |
| 339 def gotLastResult(self, result): | |
| 340 colormap = {SUCCESS: 'green', | |
| 341 FAILURE: 'red', | |
| 342 WARNINGS: 'orange', | |
| 343 EXCEPTION: 'purple', | |
| 344 } | |
| 345 self.last.setColor(colormap[result]) | |
| 346 | |
| 347 def getState(self): | |
| 348 self.ref.callRemote("getState").addCallback(self.gotState) | |
| 349 def gotState(self, res): | |
| 350 state, ETA, builds = res | |
| 351 # state is one of: offline, idle, waiting, interlocked, building | |
| 352 # TODO: ETA is going away, you have to look inside the builds to get | |
| 353 # that value | |
| 354 currentmap = {"offline": "red", | |
| 355 "idle": "white", | |
| 356 "waiting": "yellow", | |
| 357 "interlocked": "yellow", | |
| 358 "building": "yellow",} | |
| 359 text = state | |
| 360 self.current.setColor(currentmap[state]) | |
| 361 if ETA is not None: | |
| 362 text += "\nETA=%s secs" % ETA | |
| 363 self.current.setText(state) | |
| 364 | |
| 365 def buildStarted(self, build): | |
| 366 print "[%s] buildStarted" % (self.name,) | |
| 367 self.current.setColor("yellow") | |
| 368 | |
| 369 def buildFinished(self, build, results): | |
| 370 print "[%s] buildFinished: %s" % (self.name, results) | |
| 371 self.gotLastBuild(build) | |
| 372 self.current.setColor("white") | |
| 373 self.current.stopTimer() | |
| 374 | |
| 375 def buildETAUpdate(self, eta): | |
| 376 print "[%s] buildETAUpdate: %s" % (self.name, eta) | |
| 377 self.current.setETA(eta) | |
| 378 | |
| 379 | |
| 380 def stepStarted(self, stepname, step): | |
| 381 print "[%s] stepStarted: %s" % (self.name, stepname) | |
| 382 self.step.setText(stepname) | |
| 383 self.step.setColor("yellow") | |
| 384 def stepFinished(self, stepname, step, results): | |
| 385 print "[%s] stepFinished: %s %s" % (self.name, stepname, results) | |
| 386 self.step.setText("idle") | |
| 387 self.step.setColor("white") | |
| 388 self.step.stopTimer() | |
| 389 def stepETAUpdate(self, stepname, eta): | |
| 390 print "[%s] stepETAUpdate: %s %s" % (self.name, stepname, eta) | |
| 391 self.step.setETA(eta) | |
| 392 | |
| 393 | |
| 394 class ThreeRowClient(pb.Referenceable): | |
| 395 def __init__(self, window): | |
| 396 self.window = window | |
| 397 self.buildernames = [] | |
| 398 self.builders = {} | |
| 399 | |
| 400 def connected(self, ref): | |
| 401 print "connected" | |
| 402 self.ref = ref | |
| 403 self.pane = gtk.VBox(False, 2) | |
| 404 self.table = gtk.Table(1+3, 1) | |
| 405 self.pane.add(self.table) | |
| 406 self.window.vb.add(self.pane) | |
| 407 self.pane.show_all() | |
| 408 ref.callRemote("subscribe", "logs", 5, self) | |
| 409 | |
| 410 def removeTable(self): | |
| 411 for child in self.table.get_children(): | |
| 412 self.table.remove(child) | |
| 413 self.pane.remove(self.table) | |
| 414 | |
| 415 def makeTable(self): | |
| 416 columns = len(self.builders) | |
| 417 self.table = gtk.Table(2, columns) | |
| 418 self.pane.add(self.table) | |
| 419 for i in range(len(self.buildernames)): | |
| 420 name = self.buildernames[i] | |
| 421 b = self.builders[name] | |
| 422 last,current,step = b.getBoxes() | |
| 423 self.table.attach(gtk.Label(name), i, i+1, 0, 1) | |
| 424 self.table.attach(last, i, i+1, 1, 2, | |
| 425 xpadding=1, ypadding=1) | |
| 426 self.table.attach(current, i, i+1, 2, 3, | |
| 427 xpadding=1, ypadding=1) | |
| 428 self.table.attach(step, i, i+1, 3, 4, | |
| 429 xpadding=1, ypadding=1) | |
| 430 self.table.show_all() | |
| 431 | |
| 432 def rebuildTable(self): | |
| 433 self.removeTable() | |
| 434 self.makeTable() | |
| 435 | |
| 436 def remote_builderAdded(self, buildername, builder): | |
| 437 print "builderAdded", buildername | |
| 438 assert buildername not in self.buildernames | |
| 439 self.buildernames.append(buildername) | |
| 440 | |
| 441 b = ThreeRowBuilder(buildername, builder) | |
| 442 self.builders[buildername] = b | |
| 443 self.rebuildTable() | |
| 444 b.getLastBuild() | |
| 445 b.getState() | |
| 446 | |
| 447 def remote_builderRemoved(self, buildername): | |
| 448 del self.builders[buildername] | |
| 449 self.buildernames.remove(buildername) | |
| 450 self.rebuildTable() | |
| 451 | |
| 452 def remote_builderChangedState(self, name, state, eta): | |
| 453 self.builders[name].gotState((state, eta, None)) | |
| 454 def remote_buildStarted(self, name, build): | |
| 455 self.builders[name].buildStarted(build) | |
| 456 def remote_buildFinished(self, name, build, results): | |
| 457 self.builders[name].buildFinished(build, results) | |
| 458 | |
| 459 def remote_buildETAUpdate(self, name, build, eta): | |
| 460 self.builders[name].buildETAUpdate(eta) | |
| 461 def remote_stepStarted(self, name, build, stepname, step): | |
| 462 self.builders[name].stepStarted(stepname, step) | |
| 463 def remote_stepFinished(self, name, build, stepname, step, results): | |
| 464 self.builders[name].stepFinished(stepname, step, results) | |
| 465 | |
| 466 def remote_stepETAUpdate(self, name, build, stepname, step, | |
| 467 eta, expectations): | |
| 468 # expectations is a list of (metricname, current_value, | |
| 469 # expected_value) tuples, so that we could show individual progress | |
| 470 # meters for each metric | |
| 471 self.builders[name].stepETAUpdate(stepname, eta) | |
| 472 | |
| 473 def remote_logStarted(self, buildername, build, stepname, step, | |
| 474 logname, log): | |
| 475 pass | |
| 476 | |
| 477 def remote_logFinished(self, buildername, build, stepname, step, | |
| 478 logname, log): | |
| 479 pass | |
| 480 | |
| 481 | |
| 482 class GtkClient(TextClient): | |
| 483 ClientClass = ThreeRowClient | |
| 484 | |
| 485 def __init__(self, master): | |
| 486 self.master = master | |
| 487 | |
| 488 w = gtk.Window() | |
| 489 self.w = w | |
| 490 #w.set_size_request(64,64) | |
| 491 w.connect('destroy', lambda win: gtk.main_quit()) | |
| 492 self.vb = gtk.VBox(False, 2) | |
| 493 self.status = gtk.Label("unconnected") | |
| 494 self.vb.add(self.status) | |
| 495 self.listener = self.ClientClass(self) | |
| 496 w.add(self.vb) | |
| 497 w.show_all() | |
| 498 | |
| 499 def connected(self, ref): | |
| 500 self.status.set_text("connected") | |
| 501 TextClient.connected(self, ref) | |
| 502 | |
| 503 """ | |
| 504 def addBuilder(self, name, builder): | |
| 505 Client.addBuilder(self, name, builder) | |
| 506 self.pane.addBuilder(builder) | |
| 507 def removeBuilder(self, name): | |
| 508 self.pane.removeBuilder(name, self.builders[name]) | |
| 509 Client.removeBuilder(self, name) | |
| 510 | |
| 511 def startConnecting(self, master): | |
| 512 self.master = master | |
| 513 Client.startConnecting(self, master) | |
| 514 self.status.set_text("connecting to %s.." % master) | |
| 515 def connected(self, remote): | |
| 516 Client.connected(self, remote) | |
| 517 self.status.set_text(self.master) | |
| 518 remote.notifyOnDisconnect(self.disconnected) | |
| 519 def disconnected(self, remote): | |
| 520 self.status.set_text("disconnected, will retry") | |
| 521 """ | |
| 522 | |
| 523 def main(): | |
| 524 master = "localhost:8007" | |
| 525 if len(sys.argv) > 1: | |
| 526 master = sys.argv[1] | |
| 527 c = GtkClient(master) | |
| 528 c.run() | |
| 529 | |
| 530 if __name__ == '__main__': | |
| 531 main() | |
| 532 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 12207158:
Bye bye buildbot 0.7.12. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/tools/build