WebMelody project Homepage

Project Team:

A brief description:

• mod_musical_log a module that analyzes the WWW server activity by parsing HTTP requests/responses. Interesting events (as configured by the Webmaster) are annotated and, then, proper playing requests are sent to the Collector module. The module mod_musical_log has been coded as a third-party Apache module.
• Collector, a Java application in charge of receiving playing requests from the mod_musical_log, interpret them and then forward them to one (or more) Web Players.
• WebPlayer, a Java based audio player that connects to a (remote) Collector and plays audio tracks according to received information.

Documentation, papers and samples:

• At WWW 9 in Amsterdam (May 2000): the short paper and poster presentation (slides).
• Technical Documentation:
  • Apache module mod_musical_log configuration directives and an example of the configuration file.
• Samples:
  • an MP3 file of a brief sample log file. The style is rather abstract and should avoid fatigue in the listener (i.e. since it does not appeal to rythm and known musical patterns, it can be listened for a long time without disturbing).
    The events are mapped to GrandPiano (critical errors, such as 500 HTTP errors and similar), Woodblock (access by User-Agent Netscape), MusicBox (access by User-Agent MS Internet Explorer), Trumpet (access to a directory).
    Any suitable MP3 player like Windows Media Player (http://www.microsoft.com/windowsmedia), WinAmp (http://www.winamp.com) for Window-based machine or XAudio (http://www.xaudio.com) for several Unix systems will play the MP3 file.
  • The second sample is a more Jazz-like example in the style of a Swing jam-session. Here load is mapped to the rythm (drums and bass), while different events are mapped to Piano and Organ, with the errors played by Timpani.

Installations Notes:

1. Collector
2. Apache Web server
3. WebPlayers

     java webPlayer 

In the download, we also include jazz.mid and cool.mid (beware! this is large!) MIDI tracks that must be placed on a Web server to be read by webPlayers. The location of the midi file used to play must be included into the Apache httpd.conf configuration file.

Apache module mod_musical_log:

To add mod_musical_log module to the server Apache (version 1.3.6 for Unix or later versions) you can statically compile it or install it into its own DSO mod_musical_log.so.

1. Adding a Static Module.
   Adding mod_musical_log to Apache statically:
   • Place the module source code file in the Apache src/modules/extra directory
   • Edit the Configuration file in the src directory and add a new line corresponding to this additional module you have downloaded. It's preferible inserting this line as the last line.

          AddModule modules/extra/mod_musical_log.o
     

   • Re-compile Apache by running

         ./Configure
         make
     

   • Stop your current server (with kill -TERM pid).
   The next step is to edit the server configuration file httpd.conf. This consists of setting up various directives introduced by mod_musical_log to define server profiles to monitor.
   For more informations how to do it, see Compiling and installing from Apache documentation.
   
2. Adding mod_musical_log to Apache dinamically.
   To simplify creation of DSO files for Apache modules outside of the Apache source tree you can use apxs(APache eXtenSion) tool. When installing Apache the configure's make install procedure installs the Apache C header files and puts the platform-dependent compiler and linker flags for building DSO files into the apxs program. This way the user can use apxs to compile his Apache module sources without the Apache distribution source tree and without having to fiddle with the platform-dependent compiler and linker flags for DSO support. Once you have Apache compiled with dynamic module support, you can use the support tool,apxs (in the src/support directory) for adding additional modules normally without having to reconfigure or recompile Apache itself (for more informations see dso.html ). This tool builds the module for dynamic loading, installs it into the live Apache directory and adds the required LoadModule line to the Apache configuration files.

         $ cd /path/to/3rdparty
         $ apxs -c mod_musical_log.c
         $ apxs -i -a -n musical_log mod_musical_log.so
   

   If no new line is added to the Apache configuration file (httpd.conf) after running of this script, manually add :

      LoadModule musical_log_module /path/to/install/libexec/mod_musical_log.so
   

   and

       AddModule mod_musical_log.c
   

   
   These new lines must be last lines respectively in LoadModule directive and AddModule directive lists in the configuration file. In this way mod_musical_log will be the first module to be contacted during HTTP requests processing loop in phases that it manages. This allows to obtain best valuation of the server workload. The next step is to edit the configuration files for the server. This consists of setting up various directives introduced by mod_musical_log to define server profiles to monitor.
   Now you can send a USR1 signal to Apache (typically with the apachectl script) to get it to re-read the configuration and load in the new module without affecting transfers in progress.

The Collector:

Collector is a module in charge of receiving information from the mod_musical_log about HTTP events. Its goal is store the data to interpret them and then to forward proper playing requests to Web Players that connected to it. The Collector is a Java application containing a server to manage WebPlayers sonification requests and a server to manage communications with Apache servers.

Multiple Apache servers could connect to the Collector and for each of it multiple WebPlayers can contact the Collector. However actually only a Web server can be sonified.

The Collector java application can be run using the Java Runtime Environment (JRE) or the Java Development Kit (JDK) 1.3 virtual machines both availables from http://java.sun.com . The Collector is the first system component you must start up. Its default port number is 7000 (to be contacted by Apache servers) but you can also select another number specifing it on command line. To start the Collector is made with:

java Collector [port]

It is preferible the Collector and server Apache be locate on the same host to have best results (because of delays). Each time an Apache server contacts the Collector a new port number is indicate on the screen. This port number must be used by WebPlayers that want to sonify that HTTP server. Actually port number is 4444. So WebPlayers can establish a connection with the Collector after a Collector-Apache connection.

The Collector starts to collect Apache server information when receives first HTTP request/response communication from the server.
When a new WebPlayer or Apache server connect/disconnect to Collector a line is visualized on standard output.
For each Apache communication, information received by Collector are displayed to help you to understand which bit strings are sent to WebPlayers. For each Channel a batch of bit string are displayed according user-specified configuration.

The WebPlayer:

The WebPlayer uses the Java Sound technology to is a Java application, to be able to run . You need Java Runtime Environment 1.3 or the Java Developers Kit 1.3 (available at http://www.javasoft.com/j2se/) and one of the supported audio card installed on your computer. Untar the file distributed in a directory, change the ClassPath so that it includes . (current directory) and type:

java webPlayer

The GUI of WebPlayer allows the user to perform the following tasks (in this order):

1. select the location of a remote Collector from a list of pre-filled standard addresses (where it says "server" it means Collector)
2. connect to a remote Collector (by clicking on the icon on the right) using the currently selected address for the Collector;
3. switch among several sonification channels provided by the current Collector (the first channel is the default).

Note that WebPlayer uses several internal buffers to store data sent from a remote Collector. The bufferization of data allows to minimize problems concerning the network degradation and allows a better audio playback. For this reason, when switching to a new Channel the user must wait several seconds before listening to the selected channel (typically the delay ranges from 30 to 60 seconds).

Contact Information: