| #! /usr/bin/python |
| |
| # This is a Gnome-2 panel applet that uses the |
| # buildbot.status.client.PBListener interface to display a terse summary of |
| # the buildmaster. It displays one column per builder, with a box on top for |
| # the status of the most recent build (red, green, or orange), and a somewhat |
| # smaller box on the bottom for the current state of the builder (white for |
| # idle, yellow for building, red for offline). There are tooltips available |
| # to tell you which box is which. |
| |
| # Edit the line at the beginning of the MyApplet class to fill in the host |
| # and portnumber of your buildmaster's PBListener status port. Eventually |
| # this will move into a preferences dialog, but first we must create a |
| # preferences dialog. |
| |
| # See the notes at the end for installation hints and support files (you |
| # cannot simply run this script from the shell). You must create a bonobo |
| # .server file that points to this script, and put the .server file somewhere |
| # that bonobo will look for it. Only then will this applet appear in the |
| # panel's "Add Applet" menu. |
| |
| # Note: These applets are run in an environment that throws away stdout and |
| # stderr. Any logging must be done with syslog or explicitly to a file. |
| # Exceptions are particularly annoying in such an environment. |
| |
| # -Brian Warner, warner@lothar.com |
| |
| if 0: |
| import sys |
| dpipe = open("/tmp/applet.log", "a", 1) |
| sys.stdout = dpipe |
| sys.stderr = dpipe |
| print "starting" |
| |
| from twisted.internet import gtk2reactor |
| gtk2reactor.install() #@UndefinedVariable |
| |
| import gtk #@UnresolvedImport |
| import gnomeapplet #@UnresolvedImport |
| |
| # preferences are not yet implemented |
| MENU = """ |
| <popup name="button3"> |
| <menuitem name="Connect" verb="Connect" label="Connect" |
| pixtype="stock" pixname="gtk-refresh"/> |
| <menuitem name="Disconnect" verb="Disconnect" label="Disconnect" |
| pixtype="stock" pixname="gtk-stop"/> |
| <menuitem name="Prefs" verb="Props" label="_Preferences..." |
| pixtype="stock" pixname="gtk-properties"/> |
| </popup> |
| """ |
| |
| from twisted.spread import pb |
| from twisted.cred import credentials |
| |
| # sigh, these constants should cross the wire as strings, not integers |
| SUCCESS, WARNINGS, FAILURE, SKIPPED, EXCEPTION = range(5) |
| Results = ["success", "warnings", "failure", "skipped", "exception"] |
| |
| |
| class Box: |
| |
| def __init__(self, buildername, hbox, tips, size, hslice): |
| self.buildername = buildername |
| self.hbox = hbox |
| self.tips = tips |
| self.state = "idle" |
| self.eta = None |
| self.last_results = None |
| self.last_text = None |
| self.size = size |
| self.hslice = hslice |
| |
| def create(self): |
| self.vbox = gtk.VBox(False) |
| l = gtk.Label(".") |
| self.current_box = box = gtk.EventBox() |
| # these size requests are somewhat non-deterministic. I think it |
| # depends upon how large label is, or how much space was already |
| # consumed when the box is added. |
| self.current_box.set_size_request(self.hslice, self.size * 0.75) |
| box.add(l) |
| self.vbox.pack_end(box) |
| self.current_box.modify_bg(gtk.STATE_NORMAL, |
| gtk.gdk.color_parse("gray50")) |
| |
| l2 = gtk.Label(".") |
| self.last_box = gtk.EventBox() |
| self.current_box.set_size_request(self.hslice, self.size * 0.25) |
| self.last_box.add(l2) |
| self.vbox.pack_end(self.last_box, True, True) |
| self.vbox.show_all() |
| self.hbox.pack_start(self.vbox, True, True) |
| |
| def remove(self): |
| self.hbox.remove(self.box) |
| |
| def set_state(self, state): |
| self.state = state |
| self.update() |
| |
| def set_eta(self, eta): |
| self.eta = eta |
| self.update() |
| |
| def set_last_build_results(self, results): |
| self.last_results = results |
| self.update() |
| |
| def set_last_build_text(self, text): |
| self.last_text = text |
| self.update() |
| |
| def update(self): |
| currentmap = {"offline": "red", |
| "idle": "white", |
| "waiting": "yellow", |
| "interlocked": "yellow", |
| "building": "yellow", |
| } |
| color = currentmap[self.state] |
| self.current_box.modify_bg(gtk.STATE_NORMAL, |
| gtk.gdk.color_parse(color)) |
| lastmap = {None: "gray50", |
| SUCCESS: "green", |
| WARNINGS: "orange", |
| FAILURE: "red", |
| EXCEPTION: "purple", |
| } |
| last_color = lastmap[self.last_results] |
| self.last_box.modify_bg(gtk.STATE_NORMAL, |
| gtk.gdk.color_parse(last_color)) |
| current_tip = "%s:\n%s" % (self.buildername, self.state) |
| if self.eta is not None: |
| current_tip += " (ETA=%ds)" % self.eta |
| self.tips.set_tip(self.current_box, current_tip) |
| last_tip = "%s:\n" % self.buildername |
| if self.last_text: |
| last_tip += "\n".join(self.last_text) |
| else: |
| last_tip += "no builds" |
| self.tips.set_tip(self.last_box, last_tip) |
| |
| |
| class MyApplet(pb.Referenceable): |
| # CHANGE THIS TO POINT TO YOUR BUILDMASTER |
| buildmaster = "buildmaster.example.org", 12345 |
| filled = None |
| |
| def __init__(self, container): |
| self.applet = container |
| self.size = container.get_size() |
| self.hslice = self.size / 4 |
| container.set_size_request(self.size, self.size) |
| self.fill_nut() |
| verbs = [("Props", self.menu_preferences), |
| ("Connect", self.menu_connect), |
| ("Disconnect", self.menu_disconnect), |
| ] |
| container.setup_menu(MENU, verbs) |
| self.boxes = {} |
| self.connect() |
| |
| def fill(self, what): |
| if self.filled: |
| self.applet.remove(self.filled) |
| self.filled = None |
| self.applet.add(what) |
| self.filled = what |
| self.applet.show_all() |
| |
| def fill_nut(self): |
| i = gtk.Image() |
| i.set_from_file("/tmp/nut32.png") |
| self.fill(i) |
| |
| def fill_hbox(self): |
| self.hbox = gtk.HBox(True) |
| self.fill(self.hbox) |
| |
| def connect(self): |
| host, port = self.buildmaster |
| cf = pb.PBClientFactory() |
| creds = credentials.UsernamePassword("statusClient", "clientpw") |
| d = cf.login(creds) |
| reactor.connectTCP(host, port, cf) |
| d.addCallback(self.connected) |
| return d |
| |
| def connected(self, ref): |
| print "connected" |
| ref.notifyOnDisconnect(self.disconnected) |
| self.remote = ref |
| self.remote.callRemote("subscribe", "steps", 5, self) |
| self.fill_hbox() |
| self.tips = gtk.Tooltips() |
| self.tips.enable() |
| |
| def disconnect(self): |
| self.remote.broker.transport.loseConnection() |
| |
| def disconnected(self, *args): |
| print "disconnected" |
| self.fill_nut() |
| |
| def remote_builderAdded(self, buildername, builder): |
| print "builderAdded", buildername |
| box = Box(buildername, self.hbox, self.tips, self.size, self.hslice) |
| self.boxes[buildername] = box |
| box.create() |
| self.applet.set_size_request(self.hslice * len(self.boxes), |
| self.size) |
| d = builder.callRemote("getLastFinishedBuild") |
| |
| def _got(build): |
| if build: |
| d1 = build.callRemote("getResults") |
| d1.addCallback(box.set_last_build_results) |
| d2 = build.callRemote("getText") |
| d2.addCallback(box.set_last_build_text) |
| d.addCallback(_got) |
| |
| def remote_builderRemoved(self, buildername): |
| self.boxes[buildername].remove() |
| del self.boxes[buildername] |
| self.applet.set_size_request(self.hslice * len(self.boxes), |
| self.size) |
| |
| def remote_builderChangedState(self, buildername, state, eta): |
| self.boxes[buildername].set_state(state) |
| self.boxes[buildername].set_eta(eta) |
| print "change", buildername, state, eta |
| |
| def remote_buildStarted(self, buildername, build): |
| print "buildStarted", buildername |
| |
| def remote_buildFinished(self, buildername, build, results): |
| print "buildFinished", results |
| box = self.boxes[buildername] |
| box.set_eta(None) |
| d1 = build.callRemote("getResults") |
| d1.addCallback(box.set_last_build_results) |
| d2 = build.callRemote("getText") |
| d2.addCallback(box.set_last_build_text) |
| |
| def remote_buildETAUpdate(self, buildername, build, eta): |
| self.boxes[buildername].set_eta(eta) |
| print "ETA", buildername, eta |
| |
| def remote_stepStarted(self, buildername, build, stepname, step): |
| print "stepStarted", buildername, stepname |
| |
| def remote_stepFinished(self, buildername, build, stepname, step, results): |
| pass |
| |
| def menu_preferences(self, event, data=None): |
| print "prefs!" |
| p = Prefs(self) |
| p.create() |
| |
| def set_buildmaster(self, buildmaster): |
| host, port = buildmaster.split(":") |
| self.buildmaster = host, int(port) |
| self.disconnect() |
| reactor.callLater(0.5, self.connect) |
| |
| def menu_connect(self, event, data=None): |
| self.connect() |
| |
| def menu_disconnect(self, event, data=None): |
| self.disconnect() |
| |
| |
| class Prefs: |
| |
| def __init__(self, parent): |
| self.parent = parent |
| |
| def create(self): |
| self.w = w = gtk.Window() |
| v = gtk.VBox() |
| h = gtk.HBox() |
| h.pack_start(gtk.Label("buildmaster (host:port) : ")) |
| self.buildmaster_entry = b = gtk.Entry() |
| if self.parent.buildmaster: |
| host, port = self.parent.buildmaster |
| b.set_text("%s:%d" % (host, port)) |
| h.pack_start(b) |
| v.add(h) |
| |
| b = gtk.Button("Ok") |
| b.connect("clicked", self.done) |
| v.add(b) |
| |
| w.add(v) |
| w.show_all() |
| |
| def done(self, widget): |
| buildmaster = self.buildmaster_entry.get_text() |
| self.parent.set_buildmaster(buildmaster) |
| self.w.unmap() |
| |
| |
| def factory(applet, iid): |
| MyApplet(applet) |
| applet.show_all() |
| return True |
| |
| |
| from twisted.internet import reactor |
| |
| # instead of reactor.run(), we do the following: |
| reactor.startRunning() |
| reactor.simulate() |
| gnomeapplet.bonobo_factory("OAFIID:GNOME_Buildbot_Factory", |
| gnomeapplet.Applet.__gtype__, |
| "buildbot", "0", factory) |
| |
| # code ends here: bonobo_factory runs gtk.mainloop() internally and |
| # doesn't return until the program ends |
| |
| # SUPPORTING FILES: |
| |
| # save the following as ~/lib/bonobo/servers/bb_applet.server, and update all |
| # the pathnames to match your system |
| bb_applet_server = """ |
| <oaf_info> |
| |
| <oaf_server iid="OAFIID:GNOME_Buildbot_Factory" |
| type="exe" |
| location="/home/warner/stuff/buildbot-trunk/contrib/bb_applet.py"> |
| |
| <oaf_attribute name="repo_ids" type="stringv"> |
| <item value="IDL:Bonobo/GenericFactory:1.0"/> |
| <item value="IDL:Bonobo/Unknown:1.0"/> |
| </oaf_attribute> |
| <oaf_attribute name="name" type="string" value="Buildbot Factory"/> |
| <oaf_attribute name="description" type="string" value="Test"/> |
| </oaf_server> |
| |
| <oaf_server iid="OAFIID:GNOME_Buildbot" |
| type="factory" |
| location="OAFIID:GNOME_Buildbot_Factory"> |
| |
| <oaf_attribute name="repo_ids" type="stringv"> |
| <item value="IDL:GNOME/Vertigo/PanelAppletShell:1.0"/> |
| <item value="IDL:Bonobo/Control:1.0"/> |
| <item value="IDL:Bonobo/Unknown:1.0"/> |
| </oaf_attribute> |
| <oaf_attribute name="name" type="string" value="Buildbot"/> |
| <oaf_attribute name="description" type="string" |
| value="Watch Buildbot status" |
| /> |
| <oaf_attribute name="panel:category" type="string" value="Utility"/> |
| <oaf_attribute name="panel:icon" type="string" |
| value="/home/warner/stuff/buildbot-trunk/doc/hexnut32.png" |
| /> |
| |
| </oaf_server> |
| |
| </oaf_info> |
| """ |
| |
| # a quick rundown on the Gnome2 applet scheme (probably wrong: there are |
| # better docs out there that you should be following instead) |
| # http://www.pycage.de/howto_bonobo.html describes a lot of |
| # the base Bonobo stuff. |
| # http://www.daa.com.au/pipermail/pygtk/2002-September/003393.html |
| |
| # bb_applet.server must be in your $BONOBO_ACTIVATION_PATH . I use |
| # ~/lib/bonobo/servers . This environment variable is read by |
| # bonobo-activation-server, so it must be set before you start any Gnome |
| # stuff. I set it in ~/.bash_profile . You can also put it in |
| # /usr/lib/bonobo/servers/ , which is probably on the default |
| # $BONOBO_ACTIVATION_PATH, so you won't have to update anything. |
| |
| # It is safest to put this in place before bonobo-activation-server is |
| # started, which may mean before any Gnome program is running. It may or may |
| # not detect bb_applet.server if it is installed afterwards.. there seem to |
| # be hooks, some of which involve FAM, but I never managed to make them work. |
| # The file must have a name that ends in .server or it will be ignored. |
| |
| # The .server file registers two OAF ids and tells the activation-server how |
| # to create those objects. The first is the GNOME_Buildbot_Factory, and is |
| # created by running the bb_applet.py script. The second is the |
| # GNOME_Buildbot applet itself, and is created by asking the |
| # GNOME_Buildbot_Factory to make it. |
| |
| # gnome-panel's "Add To Panel" menu will gather all the OAF ids that claim |
| # to implement the "IDL:GNOME/Vertigo/PanelAppletShell:1.0" in its |
| # "repo_ids" attribute. The sub-menu is determined by the "panel:category" |
| # attribute. The icon comes from "panel:icon", the text displayed in the |
| # menu comes from "name", the text in the tool-tip comes from "description". |
| |
| # The factory() function is called when a new applet is created. It receives |
| # a container that should be populated with the actual applet contents (in |
| # this case a Button). |
| |
| # If you're hacking on the code, just modify bb_applet.py and then kill -9 |
| # the running applet: the panel will ask you if you'd like to re-load the |
| # applet, and when you say 'yes', bb_applet.py will be re-executed. Note that |
| # 'kill PID' won't work because the program is sitting in C code, and SIGINT |
| # isn't delivered until after it surfaces to python, which will be never. |
| |
| # Running bb_applet.py by itself will result in a factory instance being |
| # created and then sitting around forever waiting for the activation-server |
| # to ask it to make an applet. This isn't very useful. |
| |
| # The "location" filename in bb_applet.server must point to bb_applet.py, and |
| # bb_applet.py must be executable. |
| |
| # Enjoy! |
| # -Brian Warner |
