Although, everytime I install an OS I leave the old one on, just in case. That machine can now boot LFS, Fedora 9, Ubuntu 10.04 or Windows 98. Windows 98? Well, how else do I play Quake or MechWarrior 2, etc, etc?

But when I installed version 2.9 I decided to split it between one tech-based blog and one personal blog. To do this I added a second WordPress installation in a subdirectory of the current one and created some links between the two. Now it turns out that in the new WordPress 3.0 version you can have multiple blogs, just my luck!

It was MySQL 5.0′s lack of support of ‘DROP TRIGGER IF EXISTS’ which started me off on this upgrade, because I use MYSQL Workbench and the latest version automatically inserts a drop if exists when applying changes to an existing trigger.

The first issue during this upgrade was not knowing that Sun/Oracle (not sure who was in charge when this decision was made) had opted to remove the InnoDB engine and make it available as a plugin. I should have read through the extensive change log, but I didn’t. But the documentation definately needs to be updated about how you include the InnoDB engine when running configure. The INSTALL-SOURCE file suggests –with-innodb, I’ve also seen –with-plugin-innodb and –with-plugin=innodb. None of these work, certainly not with MySQL 5.1.48 source.

After trawling through the configure script I finally found it and managed to configure it with InnoDB support with:

./configure --prefix=/usr/local/mysql --with-plugins=innobase,innodb_plugin

I’m not entirely sure at this point whether I really need innobase, I couldn’t find any information on it.

The compilation and install seemed to go without a hitch, but takes several hours on this creaky old machine. Unfortunately the mysql_install_db script is now hanging before fully creating the database, so that’s the current brick wall.

But I’m still not changing my RH9 server, for sentimental reasons…

Turns out it was just a case of setting up the location of the JW ImageRotator file.

Unfortunately the pretty ngg-gallery slideshow widget isn’t working since I upgraded, which just adds insult to injury.

As this system is turn based I intend to allow a turn period to be set as part of the starting parameters. But also provide the option to have this as a maximum turn duration, and process turns as soon as all players have submitted their turn. Since turn processing will take a matter of seconds and the next turn will start once processing has completed, it would actually be possible for all players to be logged in at the same time and submit turn after turn.

I was surprised to see how little documentation there is on the ‘BEFORE’ and ‘AFTER’ keywords. I was looking for something that would explain to me when I should use each of these, and wherever I found *something* on it, it wasn’t enough.

Through a little bit of testing however, I have found that using ‘AFTER’ delivers desirable results for Inserts, Updates and Deletes. Is it important? Well, considering that after performing the tasks of a ‘BEFORE’ trigger the actual Insert, Update or Delete might fail, but this doesn’t undo the effects of the trigger. Using ‘AFTER’ triggers ensures that the task has completed before we create the audit record.

An example of auditing triggers, for Insert, Update and Delete:

CREATE TRIGGER mytable_audit_trigger_insert
AFTER INSERT ON mytable
FOR EACH ROW BEGIN
    INSERT INTO mytable_audit (
        id, date, name
    )
    VALUES(
        NEW.id, NOW(), NEW.name
    );
END;

CREATE TRIGGER mytable_audit_trigger_update
AFTER UPDATE ON mytable
FOR EACH ROW BEGIN
    INSERT INTO mytable_audit (
        id, date, name
    )
    VALUES(
        NEW.id, NOW(), NEW.name
    );
END;

CREATE TRIGGER mytable_audit_trigger_delete
AFTER DELETE ON mytable
FOR EACH ROW BEGIN
    INSERT INTO mytable_audit (
        id, date, name
    )
    VALUES(
        OLD.id, NOW(), OLD.name
    );
END;

It would be nice to be able to query/edit triggers, but unfortunately you can only CREATE and DROP them, certainly within the MySQL Query Browser. I’ve not tried any 3rd party tools as I’m happy to keep .sql files, with the details of the CREATE TRIGGER statements so I know what’s in them.

This is why I chose to implement the SPI model for my browser-based application framework, primarily intended for strategy/RPG gaming. Since users will need to be authenticated by the application before they can use it, and once logged in they are presented with navigational controls via menus and other web controls, I see no real requirement for them to bookmark anything other than the main application page. Which they are free to do. Admittedly, particularly in the case of online gaming, there would generally be some content intended for non-members, introduction to the application and enticing screenshots etc, which they may feel the need to bookmark. But if a sufficiently intuitive public menu is on offer then bookmarking and browsing history is still not really necessary.

Anyway, enough of justifying my apparent laziness ;P Time for some code…

I devised an XMLHttpRequest model which uses a single Ajax callback function that receives XML containing individual page updates. For example I have started with a two part interface made up of a menu and main content area. When the user clicks on a menu option an XMLHttpRequest is sent to a specific server-side script for that menu option which will compile an XML update document and pass it back. This will then be picked up from my one, generic callback function. This will then extract each xml page update and perform each update on the page. These updates will specify an ID, which relates to an element on the page.

For example, consider a very simplified situation below, with 2 menu items for introduction and about us sections, a header section that just informs the user where they are in the application and a main content section initially displaying the introduction:

<html>
  <body>
    <div id="header">Introduction</div>
    <div id="menu">
      <div onclick="AjaxReq('intro');">Introduction</div>
      <div onclick="AjaxReq('about');">About Us</div.
    </div>
    <div id="main">
      This is the introduction page.
    </div>
  </body>
</html>

The AjaxReq function will then look at it’s one parameter and call the appropriate server-side script, in this case maybe either intro{.php,.asp,.aspx,etc.} or aboutus for example. The aboutus script might then return the following XML:

<?xml version="1.0" encoding="iso-8859-1"?>
<updates>
  <update target="header">
    <![CDATA[
      About Us
    ]]>
  </update>
  <update target="main">
    <![CDATA[
      This is the about us page.
    ]]>
  </update>
</updates>

The generic callack function that receives this can then simply replace the contents of each of the html elements specified by the target attributes, with the contents of the CDATA sections. This will give a page that looks like:

<html>
  <body>
    <div id="header">About Us</div>
    <div id="menu">
      <div onclick="AjaxReq('intro');">Introduction</div>
      <div onclick="AjaxReq('about');">About Us</div.
    </div>
    <div id="main">
      This is the about us page.
    </div>
  </body>
</html>

So a single Ajax request-response can make several updates to the page. So we could expand this to also update the menu if we wanted to include sub-menus.

Also, a single section might have a specific layout and controls within the “main” element, whose controls make Ajax requests that return updates for elements specific to that “main” section. This is made easier by the addition of passing parameters in the request. So not only can you start with a simple menu-content layout, but each of those sections could load sub-sections whose content can be updated directly.

Time for an example of the Javascript Ajax request and callback functions that could be used in an application implementing this method. These also rely on the use of the prototype library. Here’s the Ajax request function:

function AjaxRequest(url, params, callBack) {
    new Ajax.Request(url, {
        parameters: params,
        onSuccess: callBack,
        onFailure: AjaxRequestError
    });
}

Here’s the generic callback function:

function AjaxResponse(req) {
    var xmlDoc = req.responseXML;
    var xhtmlUpdate = xmlDoc.getElementsByTagName("xhtmlupdate");
    var i,target;
    for(i=0; i<xhtmlUpdate.length; i++) {
        target = xhtmlUpdate[i].getAttribute("target");
        xhtml = GetNodeXML(xhtmlUpdate[i]);
        // Clear previous data.
        while($(target).hasChildNodes()) {
            $(target).removeChild($(target).lastChild);
        }
        // Add new data if there is any.
        if (xhtml != "") {
            var tmpDiv = document.createElement("div");
            tmpDiv.innerHTML = xhtml;
            $(target).appendChild(tmpDiv);
        }
    }
}

I’ve included a login section in my application framework, with the ability for a user to register an account and retrieve forgotten login details. I have also provided a public and private application menu depending on whether the user is currently logged in or not. I’m hoping to apply it to some game rules soon for a small SPI Ajax space colonisation strategy game. But I’m also thinking of moving from Prototype to JQuery.

What else have I been doing? Mostly PHP, JavaScript (although it’s on my list to give JQuery a try after listening to the FLOSS Weekly podcast no. 55), cURL, libxml2, mySQL, Visual Studio C++ 2008 Express (for my sins ;). Oh and I’ve converted myself to Gnome, after a long and painful struggle with KDE, swapping kate for gedit and not looking back, much.

Oh and more dabbling with Drupal, wrote a newsfeed reader module for grabbing news items for a website.

Well, that’s it for now, back to the grind…