Notes on a Message Passing design

I am an avid supporter of "message based" systems. I took the time to perform a quick "brain dump" of some of my thoughts on the subject.



Follows a simple Python based implementation.

	"""
	Simple "Bus" based message publish/subscribe
	Created on 2010-01-28
	@author: jldupont
	"""
	__all__=["Bus"]
	class Bus(object):
	"""
	Simple publish/subscribe "message bus"
	with configurable error reporting
	Message delivery is "synchronous i.e. the caller of
	the "publish" method blocks until all the subscribers
	of the message have been "called-back".
	Any "callback" can return "True" for stopping the
	calling chain.
	"""
	logger=None
	ftable={}
	@classmethod
	def subscribe(cls, msgType, callback):
	"""
	Subscribe to a Message Type
	@param msgType: string, unique message-type identifier
	@param callback: callable instance which will be called upon message delivery
	"""
	subs=cls.ftable.get(msgType, [])
	subs.append(callback)
	cls.ftable[msgType]=subs
	@classmethod
	def publish(cls, msgType, *pa, **kwa):
	"""
	Publish a message from a specific type on the bus
	@param msgType: string, message-type
	@param *pa: positional arguments
	@param **kwa: keyword based arguments
	"""
	subs=cls.ftable.get(msgType, [])
	for sub_cb in subs:
	try:
	stop_chain=sub_cb(msgType, *pa, **kwa)
	except Exception, e:
	stop_chain=True
	if cls.logger:
	cls.logger(msgType, e)
	if stop_chain:
	return
	## =========================================================== TESTS
	if __name__ == '__main__':
	class Logger(object):
	def __call__(self, msgType, e):
	print "Logger: Error: msgType(%s) Exception(%s)" % (msgType, str(e))
	def callback(msgType, *pa, **kwa ):
	print "cb: msgType(%s) pa(%s) kwa(%s)" % (msgType, pa, kwa)
	Bus.logger=Logger()
	Bus.subscribe("test", callback)
	Bus.subscribe("test", callback)
	Bus.publish("test", p1="v1", p2="v2")
	Bus.publish("test2", p1="v1", p2="v2")
	Bus.subscribe("test", None)
	Bus.publish("test", p2="v2", p3="v3")
	Bus.logger=None
	Bus.publish("test", p2="v2", p3="v3")

view raw Simple_Message_Bus.py hosted with ❤ by GitHub

I will very likely make other contributions to my blog along the same lines.

Message Bus for Gnome Object based Python projects

Whilst developing my latest software project (Rhythmbox plugin Last.fm sync), I have crafted a "Message Bus" based on Gnome GObject. Since I didn't have any experience at all with Gnome GObject previously, it took me sometimes to work out the details of the architecture.  For an example usage, please refer to my Git Repository.

""" 
    GObject based "Message Bus"
    
    @author: Jean-Lou Dupont
"""

import gobject #@UnresolvedImport

class Signals(gobject.GObject):
    """
    List of the application level signals
    """
    __gsignals__ = {

         ## NOTE: customization required here
         ## =================================
         ## Announces changes in the user's Last.fm properties
        "lastfm_username_changed":  (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_STRING,)) 
        ,'lastfm_password_changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_STRING,))

        ## Used to signal a change in the currently playing track
        ,"playing_song_changed":    (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_OBJECT,))
        
        ## Used to report a failure when accessing Last.fm web service
        ,'lastfm_request_failed':   (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())
        
        ## Used for distributing the results of the query against the Last.fm web service
        ,"user_track_info":         (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_OBJECT,))
        
        ## Used to pass around the "shell" global object
        ,"rb_shell":                (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (gobject.TYPE_OBJECT,))              
    }

    def __init__(self):
        gobject.GObject.__init__(self)
        
        
class Bus(object):
    """
    Message Bus
    
    Borg Pattern
    """
    _signals=Signals()

    @classmethod
    def emit(cls, name, *pa, **kwa):
        cls._signals.emit(name, *pa, **kwa)

    @classmethod
    def add_emission_hook(cls, name, callback):
        gobject.add_emission_hook(cls._signals, name, callback)
    
mbus=Bus()

## =============================================================== Tests

if __name__=="__main__":

    def callback(signal, data):
        print "callback: signal=%s, data=%s" % (signal, data)
    
    Bus.add_emission_hook("lastfm_username_changed", callback)
    
    Bus.emit("lastfm_username_changed", "jldupont")

Relevant Stackoverflow posts
Here are two Stackoverflow posts in relation with my exercise: question 1, question 2.

Rhythmbox plugin - Syncing with Last.fm

In my quest to manage my music collection seamlessly between media players, I've decided to use Last.Fm as my main database. Last.Fm provides ways to store:

• History of played tracks
• Playcount associated with played tracks
• Tags associated with tracks
• Playlists
• etc.

Through their API (see mindmap), it is possible to have access to all this information (and much more).

Rhythmbox 

My music collection is currently organized through Rhythmbox - it wasn't my first choice at the time I've moved from my Windows desktop to my Linux Ubuntu one but it has proven very useful. RB can be extended with Python scripts quite painlessly.

Last.Fm Syncing

The plugin I have developed this time supports the following features:

• When a track is played, it downloads the corresponding information from the user's Last.Fm account and updates the following fields of the Rhythmbox database:
• Playcount: if the "last.fm playcount" associated with the track is greater than 0, the local playcount of RB is updated with it
• Rating: if the "last.fm love" field is set for the track, the local "rating" field of the track is set to 5.0 (5 stars)

With this functionality, it is easier to update a local Rhythmbox media player database with information stored on a user's account on Last.fm.  The standard Last.Fm plugin of Rhythmbox must be enabled and configured correctly.

Installation

The plugin can be installed by following the procedure found at the project's home page. A direct link to the plugin Debian/Ubuntu repository is provided here.

Future

The project is far from being completed - I have many other features in the pipeline. Stay tuned!

Related project

There is a related project to this one: Rhythmbox - Last.Fm Desktop Client plugin.

Feedback is very welcome!

UPDATE: see here for details on the new release.

Rhythmbox plugin for Last.fm desktop client

I've recently lost my music database to the hands of Banshee (actually, the Sqlite3 database file is still somewhat salvageable). I have longed for an application that would make my life easy in managing my music collection (which is pretty extensive) and do this day haven't found one. The recent event pushed me to the edge: I am embarking on a quest to scratch my itch on this matter.

First step

The first step consisted in getting acquainted with Rhythmbox, my new music media player. Why Rhythmbox? because it supports a Python based extension system (compared to Banshee's C# based on) and I happen to really enjoy writing software using Python.

To this effect, I have crafted a plugin that sends the current playing state (START/PAUSED/RESUMED) of Rhythmbox to Last.fm's Desktop Client.

Plugin

The project is located on Github.

Project

I intend to make several other contributions focused on media players. My goal is to be able to synchronize my music collection seamlessly between Rhythmbox, Last.fm and iTunes (with possibly also Musicbrainz). Stay tuned!

Google Wave Invites

I've got some Google Wave invites left... first come, first served!