HPC Bits

We currently run sites which utilize three popular CMS softwares: WordPress, Drupal, and Joomla. Keeping these sites up-to-date is critical to maintaining the security of our services and so we needed an automated way to keep us notified of version changes. Enter Zabbix & Redmine.

We use Zabbix for our infrastructure monitoring and notification, alerting us when servers go down, performance values get out of whack, sites return unexpected results, etc. Zabbix has the ability to use external scripts to get item values, so the idea is to use this external check script to compare the installed version of the web application with the latest version published on the CMSes project page (taking into account major and minor releases). A few things need to be done to pull this off

1. Create a script that will take as arguments a) the hostname b) the CMS type, and then do the following:

a. check the current installed version

b. check the most current minor release of that major release series from the CMS’ project web pagreturn a value of Up-to-date if everything looks good or something else if the values don’t match

2. Create a Zabbix template that includes

a. items for each CMS, utilizing the above script

b. triggers for each item that set an alert status (informational is fine) if the return value of the script is out-of-bounds

c. an action which calls a script that utilizes the Redmine REST API to insert a ticket into the “Web Services” project

The script for doing the version checking is really quite simple, as shown below:

#!/bin/bash
#
# Tool to check for
#
# a. latest version of specified software
# b. currently installed version
#

urlPath="http://$1"
appName=$2

# functions
function _latestVersion(){
    case "$appName" in
        wordpress)  wget -O - -q http://wordpress.org/download/ |
                         egrep -o 'Download.*WordPress.*([0-9]+\.)+[0-9]+' |
                         cut -d';' -f3 ;;
        joomla15)   wget -O - -q http://developer.joomla.org/development-status.html |
                         egrep -o 'Long Term Support Release.*Joomla!.*([0-9]+\.)+[0-9]+' |
                         awk '{ print $NF }'  ;;
        drupal)     wget -O - -q http://drupal.org/download |
                         egrep -o 'Download Drupal [0-9]+\.[0-9]+' |
                         awk '{ print $NF }';;
    esac
}

function _installedVersion(){
    case "$appName" in
        wordpress)  wget -O - -q ${urlPath}/readme.html |
                         egrep -o '<br /> Version ([0-9]+\.)+[0-9]' |
                         awk '{ print $NF }' ;;
        joomla15)   wget -O - -q ${urlPath}/9bcf1daadeadbeef.php |
                          base64 -d ;;
        drupal)     wget -O - -q ${urlPath}/CHANGELOG.txt |
                          egrep -o 'Drupal [0-9]+\.[0-9]+' |
                          awk '{ print $NF }' | head -n 1;;
    esac
}

installedVersion=$(_installedVersion)
latestVersion=$(_latestVersion)

if [ -z "$latestVersion" -o -z "$installedVersion" ]; then
    exit 1
fi

if [ "$installedVersion" != "$latestVersion" ]; then
    echo "installed: $installedVersion latest: $latestVersion"
    exit 0
else
    echo "Up-to-date"
    exit 0
fi

I dropped this in my /etc/zabbix/externalscripts folder and named it vcheck. For your action, you’ll configure it to go off when your triggers go off, using the appropriate actions. You will then call this script:

#!/bin/bash
#
# Tool to insert tickets into redmine.  Arguments are as follows:
#
# vcheckticketinsert <url> <drupal|joomla15|wordpress> <installed_version>
# <current_version> <redmine_url> <redmine_project> <redmine_rest_key>
#

urlPath="http://$1"
appName=$2
installedVersion=$3
currentVersion=$4
redmineUrl=$5
defProject=$6
restAPIkey=$7

function _insertTicket(){
    oldVer=$1
    newVer=$2
    url=$3
    md5=$(echo "$oldVer $newVer $url" | md5sum | awk '{ print $1 }')

    # Check if a ticket exists...
    wget --no-check-certificate -O - -q --header="X-Redmine-API-Key:$restAPIkey" \
         ${redmineUrl}/issues.xml?project_id=$defProject  | egrep -q "${md5}"
    [ $? -eq 0 ] && return 0

    case "$appName" in
        wordpress) ticketSubject="Update ${url} WordPress ${oldVer} to ${newVer}"
                   ticketText="Wordpress update required for ${url} during next \
                               maintenance window."
        ;;
        joomla15) ticketSubject="Update ${url} Joomla! ${oldVer} to ${newVer}"
                   ticketText="Joomla! update required for ${url} during next \
                               maintenance window."
        ;;
        drupal) ticketSubject="Update ${url} Drupal ${oldVer} to ${newVer}"
                   ticketText="Drupal update required for ${url} during next \
                               maintenance window."
        ;;
    esac

    # insert the ticket...
    cat > /tmp/.vcheck_ticket_insert.$$ <<EOF
<?xml version="1.0"?>
<issue>
<subject>$ticketSubject</subject>
<project_id>$defProject</project_id>
<description>$ticketText  ${md5} --</description>
</issue>
EOF
    curl -s --insecure -H "X-Redmine-API-Key:$restAPIkey" -H \
         "Content-Type: application/xml" -X POST --data \
         "@/tmp/.vcheck_ticket_insert.$$" ${redmineUrl}/issues.xml &> /dev/null
    rm -f /tmp/.vcheck_ticket_insert.$$
}

_insertTicket $installedVersion $latestVersion $urlPath

Now, whenever a web app gets out-of-date due to a minor version increase, you’ll get a ticket in Redmine to have that update completed, keeping you completely on top of your admin responsibilities.

Automation rocks.

Whoa… never thought I’d see a commercial compiler vendor give away their product — in any meaningful way — let alone open-source it. That’s pretty awesome. I first caught wind of this from the guys at Phoronix, doing a horrible job at cloak-n-dagger referring to some project called “Drindl”. I had assumed there was some re-build of apps or of the Linux kernel by a commercial compiler and lo and behold, someone in the forums guessed it. I’ve yet to see anything else of this project “Drindl”, but I did find the github page of the PathScale EckoPath compiler: https://github.com/path64/compiler

This is going to be an incredible tool to use for building, packaging and distributing scientific applications through our planned central repository.  Of course, gcc 4.6 might by a formidable opponent, in some cases.