A note of caution: I've only very recently started learning Python, Django, and Piston - so it's likely that this isn't the best approach... It's also pretty dirty as I'm currently using a combination of rc and {'status':0, 'statusmsg':'message here'} whenever errors happen... what would be better would be to always use rc.SOMETHING and throw errors that get caught and formatted correctly - I just haven't had time to clean this all up just yet...

For now, I'm just going to paste heavily commented code - if you have any questions just post in the comments. Later I'll add some more detailed explanation on what I'm doing and why I went this direction.

handlers.py snippit

# extend the BaseHandler class so we can add some additional
# features to it (mostly to support ForeignKey and fancy urls
class BaseApiHandler(BaseHandler):
    # post_name will serve as the name of the field in our output
    # data.  My output is formatted to contain a status
    # int, status message, and the actual data
    # default names this key 'data'
    post_name = 'data'

    # this method should be overridden in derived classes to process kwargs when reading data
    # This allows for urls to contain all sorts of search stuff rather than just /pkname/number
    def process_kwarg_read(self, key, value, d_post, b_exact):
        pass

    # override 'read' so we can better handle our api's searching capabilities
    def read(self, request, *args, **kwargs):
        # d_post holds the return data along with status and statusmsg
        # i default it here just for the sake of having something to look at
        d_post = {'status':0,'statusmsg':'Nothing Happened'}
        try:
            # setup the named response object
            # select all employees then filter - querysets are lazy in django
            # the actual query is only done once data is needed, so this may
            # seem like some memory hog slow beast, but it's actually not.
            d_post[self.post_name] = self.queryset(request)
            # s_query is used to hold debug information to be shown in the statusmsg
            s_query = ''

            # b_exact allows me to search with __exact or __contains depending on what the
            # person accessing the api wants
            b_exact = False
            if 'exact' in kwargs and kwargs['exact'] <> None:
                b_exact = True
                s_query = '\'exact\':True,'

            # iterate over the kwargs passed in through urls to process the search
            for key,value in kwargs.iteritems():
                # the regex url possibilities will push None into the kwargs dictionary
                # if not specified, so just continue looping through if that's the case
                if value == None or key == 'exact':
                    continue

                # write to the s_query string so we have a nice debug message
                s_query = '%s\'%s\':\'%s\',' % (s_query, key, value)

                # now process this key/value kwarg in the derived class
                self.process_kwarg_read(key=key, value=value, d_post=d_post, b_exact=b_exact)

            # when we're done looping, this runs:
            else:
                if d_post[self.post_name].count() == 0:
                    d_post['status'] = 0
                    d_post['statusmsg'] = '%s not found with query: {%s}' % (self.post_name, s_query)
                else:
                    d_post['status'] = 1
                    d_post['statusmsg'] = '%s %s found with query: {%s}' % (d_post[self.post_name].count(), self.post_name, s_query)
        except:
            e = sys.exc_info()[1]
            d_post['status'] = 0
            d_post['statusmsg'] = 'error: %s' % e
            d_post[self.post_name] = []

        return d_post

    # this method is used in derived classes to handle modal specific data
    def process_attr_item_create(self, inst, k, v):
        pass

    def flatten_data_request(self, request):
        # note: also have to support user matching for this method as well as the update method
        attrs = self.flatten_dict(request.data)
        # support posting json data inside a 'data' post variable
        if 'data' in attrs:
            ext_posted_data = simplejson.loads(request.data.get('data'))
            attrs = self.flatten_dict(ext_posted_data)
        return attrs

    # override 'create' to allow for the 'data' POST variable, as well as do some
    # fancy ForeignKey stuff
    def create(self, request, *args, **kwargs):
        if not self.has_model():
            return rc.NOT_IMPLEMENTED

        # get the actual data that wants to be created from the api request
        attrs = self.flatten_data_request(request)

        # we need to fix ForeignKeys because self.model.objects.get(**attrs) breaks
        # when one of the fields is a dictionary.  what happens when you call 'get(...)'
        # is Django creates a MySQL query with key=value.  In cases where the value is
        # a dict, you end up with '`key`={...}' which breaks the MySQL query
        # so here we convert ForeignKeys into their corresponding pk:
        for field in self.model._meta.fields:
            if field.rel:
                # this is a ForeignKey (as far as I can tell... _meta isn't documented)
                # so we need to convert it to it's pk equivilent... there's most likely
                # a better way of doing this than hardcoding stuff...
                if field.name in attrs:
                    pkfield = field.rel.to._meta.pk.name
                    if pkfield not in attrs[field.name]:
                        return {'status':0,'statusmsg':'pk field %s missing from foreignkey field %s' % (pkfield, field.name)}
                    else:
                        attrs[field.name] = attrs[field.name][pkfield]

        try:
            inst = self.model.objects.get(**attrs)
            return rc.DUPLICATE_ENTRY
        except self.model.DoesNotExist:
            inst = self.model()
            #inst = self.model(**attrs)
            # piston does not support ForeignKey, so we need to do this by hand 
            for k,v in attrs.iteritems():
                self.process_attr_item_create(inst, k, v)
            inst.save()
            return inst
        except self.model.MultipleObjectsReturned:
            return rc.DUPLICATE_ENTRY

    # override 'update' to allow for the 'data' POST variable, as well as do some
    # fancy ForeignKey stuff
    def update(self, request, *args, **kwargs):
        if not self.has_model():
            return rc.NOT_IMPLEMENTED

        pkfield = self.model._meta.pk.name

        if pkfield not in kwargs:
            # No pk was specified
            response = rc.BAD_REQUEST
            response.write(", " + "pkfield not in kwargs")
            return response

        try:
            inst = self.queryset(request).get(pk=kwargs[pkfield])
        except ObjectDoesNotExist:
            return rc.NOT_FOUND
        except MultipleObjectsReturned: # should never happen, since we're using a PK
            response = rc.BAD_REQUEST
            response.write(", " + "MultipleObjectsReturned")
            return response

        # now grab the data from the request and update the row accordingly
        attrs = self.flatten_data_request(request)
        for k,v in attrs.iteritems():
            # fix to ForeignKey
            field = self.get_field(k)
            if field.rel:
                # this is a foreignkey, set _id attr instead...
                # note: not sure if it's correct to set _id, or if there's a way to
                # get the real name of the id like there is to get the pkname
                pkfield = field.rel.to._meta.pk.name
                if pkfield not in v:
                    return {'status':0,'statusmsg':'pk field %s missing from foreignkey field %s' % (pkfield, field.name)}
                else:
                    setattr(inst, '%s_id'%k, v[pkfield])
            else:
                setattr( inst, k, v )

        inst.save()
        return rc.ALL_OK

    # delete has to be overridden to remove 'None' url params... then run the base delete
    def delete(self, request, *args, **kwargs):
        # store the keys... you can't remove things while itterating
        del_keys = []
        for key,value in kwargs.iteritems():
            # the regex url possibilities will push None into the kwargs dictionary
            # if not specified, so just continue looping through if that's the case
            if value == None:
                del_keys.append(key)
        # now remove the bad keys from kwargs
        for key in del_keys:
            del kwargs[key]
        # now run the base delete
        return BaseHandler.delete(self, request, *args, **kwargs)

    def get_field(self, f_name):
        return [f for f in self.model._meta.fields if f.name == f_name][0]

# so here's an example handler that uses BaseApiHandler's new functionality to deal with foreign keys and better urls:
class HoursDetailHandler(BaseApiHandler):
    #allowed_methods = ('GET', 'PUT', 'POST', )
    model = HoursDetail
    exclude = ()
    post_name = 'hours_detail'

    def process_kwarg_read(self, key, value, d_post, b_exact):
        # each query is handled slightly differently... when keys are added
        # handle them in here.  python doesn't have switch statements, this
        # could theoretically be performed using a dictionary with lambda
        # expressions, however I was affraid it would mess with the way the
        # filters on the queryset work so I went for the less exciting
        # if/elif block instead

        # querying on a specific row
        if key == 'id':
            d_post[self.post_name] = d_post[self.post_name].filter(pk=value)

        # filter based on employee id - this is guaranteed to happen once
        # per query (see read(...))
        elif key == 'empid':
            d_post[self.post_name] = d_post[self.post_name].filter(emp__id__exact=value)

        # look for a specific project by id
        elif key == 'projid':
            d_post[self.post_name] = d_post[self.post_name].filter(proj__id__exact=value)

        elif key == 'datestamp' or key == 'daterange':
            d_from = None
            d_to = None
            # first, regex out the times in the case of range vs stamp
            if key == 'daterange':
                m = re.match('(?P<daterangefrom>\d{4,}[-/\.]\d{2,}[-/\.]\d{2,})(?:to|/-)(?P<daterangeto>\d{4,}[-/\.]\d{2,}[-/\.]\d{2,})', \
                             value)
                d_from = datetime.strptime(m.group('daterangefrom'), '%Y-%m-%d')
                d_to = datetime.strptime(m.group('daterangeto'), '%Y-%m-%d')
            else:
                d_from = datetime.strptime(value, '%Y-%m-%d')
                d_to = datetime.strptime(value, '%Y-%m-%d')

            # now min/max to get midnight on day1 through just before midnight on day2
            # note: this is a hack because as of the writing of this app,
            # __date doesn't yet exist as a queryable field thus any
            # timestamps not at midnight were incorrectly left out
            d_from = datetime.combine(d_from, time.min)
            d_to = datetime.combine(d_to, time.max)

            d_post[self.post_name] = d_post[self.post_name].filter(clock_time__gte=d_from)
            d_post[self.post_name] = d_post[self.post_name].filter(clock_time__lte=d_to)

        else:
            raise NameError

    def read(self, request, *args, **kwargs):
        # empid is required, so make sure it exists before running BaseApiHandler's read method
        if not('empid' in kwargs and kwargs['empid'] <> None and kwargs['empid'] >= 0):
            return {'status':0,'statusmsg':'empid cannot be empty'}
        else:
            return BaseApiHandler.read(self, request, *args, **kwargs)

    # handle foreign keys in the create process by looking them up by id
    # the 'create' method truncates the dictionary of a foreignkey down to it's
    # pk, so we need to expand that again by searching for the id in the table
    def process_attr_item_create(self, inst, k, v):
        if k == 'emp':
            setattr(inst, k, Employee.objects.get(pk=v))
        elif k == 'proj':
            setattr(inst, k, Project.objects.get(pk=v))
        else:
            setattr(inst, k, v)

urls.py

    # formatting your url like this might seem crazy, but it allows your end api user to format their api call
    # in any order they want to and you can have a single url handler here and easily add to it as you need more
    # things - note: always add before the /exact line.
    #hours_detail/id/{id}/empid/{empid}/projid/{projid}/datestamp/{datestamp}/daterange/{fromdate}to{todate}/exact
    #empid is required
    url(r'^api/hours_detail/(?:' + \
        '(?:[/]?id/(?P<id>\d+))?' + \
        '(?:[/]?empid/(?P<empid>\d+))?' + \
        '(?:[/]?projid/(?P<projid>\d+))?' + \
        '(?:[/]?datestamp/(?P<datestamp>\d{4,}[-/\.]\d{2,}[-/\.]\d{2,}))?' + \
        '(?:[/]?daterange/(?P<daterange>(?:\d{4,}[-/\.]\d{2,}[-/\.]\d{2,})(?:to|/-)(?:\d{4,}[-/\.]\d{2,}[-/\.]\d{2,})))?' + \
        ')+(?:/(?P<exact>exact))?$', hours_detail_resource),

models.py (for reference)

# here's what the HoursDetail model looks like, you can see it has several foreign keys
class HoursDetail(models.Model):
    #id = models.IntegerField(primary_key=True)
    emp = models.ForeignKey(Employee)
    proj = models.ForeignKey(Project)
    datestamp = models.DateTimeField(null=True, blank=True)
    entry_type = models.CharField(max_length=192)
    hours_per_day = models.FloatField(default=0, blank=True)
    clock_time = models.DateTimeField(null=True, blank=True)
    is_clockin = models.BooleanField(default=False)
    status = models.CharField(max_length=255, null=True, blank=True)
    def __unicode__(self):
        return '%s, %s on %s worked on %s' % (self.emp.lname, self.emp.fname, self.datestamp, self.proj.name)
    class Meta:
        db_table = u'hours_detail'

Original post follows:
so a couple of weeks ago I was up far later than I should have been and managed to run the following, as root, in the root directory /

rm -rf *

What I was trying to do is delete a bunch of backup files that my backup script had been sticking in the wrong location (the smart thing would have been to copy the wrongly placed backup files into the correct place, and also not use -rf, but i'm a noob)

So, as you can imagine, after about 2 seconds (the time it took me to realize what had just happened and instantly wake up) the server was foobared. Now that it's been a couple weeks I can actually marvel at how fast rm is, it literally deleted almost everything on the server (everything that wasn't running at least) in a matter of seconds, that's pretty impressive when you are use to deleting things in windows (and I almost always shift delete, a dangerous pattern emerges...)

Anyway, so I had to re-install the OS and everything else. Luckily I had a 5 day old backup of the web and svn contents, and some chrome caches of my blog (which had all of my instructions for getting the server back up and going) so I wasn't fully up a creek. After restoring everything I did some searching around and found a way to replace rm with a move to trash bash script which is complemented by a cron that runs to clean out old trash.

Here's how to get the same thing

edit your .bashrc file and remove your rm alias (if there is one) and add the following two lines:

vim ~/.bashrc

alias rm='/usr/local/bin/del'
alias rm.old='/bin/rm -i'
alias emptytrash='/usr/local/bin/emptytrash'

rm.old will now work as rm did, however I try to forget it exists lest I do the same thing again!

Now, create the /usr/local/bin/del bash script which will look like the following:

vim /usr/local/bin/del

#!/bin/bash
# Description:  Replacement for rm. It moves files to trashbin directories
#               which are stored on each mount point. trashbins can be different
#               for each mountpoint. All trashbins are logged in TRASHBIN_LOG.

TRASH=.Trash-$USER
TRASHBIN_LOG=~/.trashbins

## this is needed to reset TRASH variable for each argument
TRASH_DIR=$TRASH

## loop through all variables that are not options, and mv each to a trashbin.
while [ ! -z $1 ]; do
    if [ ${1:0:1} = "-" ]; then
            shift
    else

    ## reset trash variable.
    ## this is important for deleteing multiple files
    TRASH=$TRASH_DIR

    ## Get the Current mount point
    MNT=`df "$1" | grep / | awk '{ for (i=6;i<=NF;i++) { printf " " $i } printf "\n"  }'`
    MNT=${MNT:1}

    ## Trash bins may be relocated depending on mount point.
    ## you may change these to your liking.
    ## TODO: this should be easier to edit, using variables
    if [ "$MNT" = "/" ]; then
        TRASH=/tmp/"$TRASH"
    elif [ "$MNT" = "/home" ]; then
        TRASH=/home/$USER/"$TRASH"
    else
        TRASH="$MNT"/"$TRASH"
    fi

    ## Test for the TRASH folder
    if [ ! -d "$TRASH" ]; then
        if mkdir "$TRASH" ; then
            chmod u+rw "$TRASH"
            echo creating $TRASH
            echo writing info to  ~/.trashbins
            echo $TRASH >> ~/.trashbins
        else
            echo ERROR: cannot create $TRASH
            exit 1;
        fi
    fi

    ## Move each file to the trash, after updating time-stamp.
         touch "$1"
         MOVETO="$TRASH/$1"
         MOVETOTWO="$TRASH/$1"
         n=0
         while [ -e $MOVETOTWO ]; do
             let "n++"
             MOVETOTWO="$TRASH/$1.$n"
         done
         mv -v "$1" "$MOVETOTWO"
    shift
    fi
done

chmod 755 /usr/local/bin/del

I also created an emptytrash script

vim /usr/local/bin/emptytrash

#!/bin/bash
#
#   Empty the contents in directories listed in ~/.trashbins
#
for i in `cat ~/.trashbins`
    do
    if  [ `ls -a1  $i | wc -l ` -gt 2 ] ; then
            find "$i" -print -delete
    fi
done

chmod 755 /usr/local/bin/emptytrash
source ~/.bashrc

Now that you've got everything set up, you'll want to make a crontab that deletes old trash. I picked 7 days as the "old enough to delete" timeframe

/etc/cron.daily/clean_trash.sh

#!/bin/bash
#
#   Empty the contents in directories listed in ~/.trashbins
#
for i in `cat ~/.trashbins`
    do
    if  [ `ls -a1  $i | wc -l ` -gt 2 ] ; then
            find "$i" -mtime +7 -delete
    fi
done 

chmod 755 /etc/cron.daily/clean_trash.sh

and there you have it... whenever you rm something it'll go into trash. you can recover it from there or you can empty the trash whenever you want. every day things that are 7 days or older in your trash folder will be deleted. and you can always run emptytrash whenever you want and it'll wipe the trash clean

I have another tutorial on how to get the latest python running in CentOS 5.4 - hopefully I'll finish writing that this weekend.

I love free

Yesterday I hooked up a post-commit script in my svn repository that automatically publishes the python code I'm currently trying to write. It's pretty cool as it allows you to source control your web(site/apps) I'll post later on how to do such a thing.

Let me preface this with the fact that if you're running one of the already supported OSs (debian or unbuntu for instance) you shouldn't follow this guide - instead you should just look on the mono website for information.

First thing I did was grab the most up-to-date mono and xst sources (i matched versions)

cd /tmp
wget http://ftp.novell.com/pub/mono/sources/mono/mono-2.6.tar.bz2
wget http://ftp.novell.com/pub/mono/sources/mod_mono/mod_mono-2.6.tar.bz2
wget http://ftp.novell.com/pub/mono/sources/xsp/xsp-2.6.tar.bz2

Then unpack everything

tar -jxvf mono-2.6.tar.bz2
 tar -jxvf xsp-2.6.tar.bz2
 tar -jxvf mod_mono-2.6.tar.bz2

then build mono first (change anything on the ./configure line to your liking, I do suggest picking a place to put mono, letting it install wherever it wants to makes the rest of the process very painful!):

cd /tmp/mono-2.6
./configure --prefix=/opt/mono
make ; make install
echo export PKG_CONFIG_PATH=/opt/mono/lib/pkgconfig:$PKG_CONFIG_PATH>>~/.bash_profile
echo export PATH=/opt/mono/bin:$PATH>>~/.bash_profile
source ~/.bash_profile

after a bit you'll have mono installed

Now build xsp (i had to add pkgconfig to an environment variable to get it to work)

cd /tmp/xsp-2.6
./configure --prefix=/opt/mono
make ; make install

Finally build mod_mono, you'll probably need to tell it where apache's apr-config is... it took a while for me to find it.. heh

find / -iname apr*config
cd /tmp/mod_mono-2.6
./configure --prefix=/opt/mono --with-mono-prefix=/opt/mono --with-apr-config=/usr/bin/apr-1-config
make ; make install

you should now find mod_mono in your apache modules dir (in my case /usr/lib64/httpd/modules/)

ls /usr/lib64/httpd/modules/mod_mono*
17 Feb  5 22:54 /usr/lib64/httpd/modules/mod_mono.so -> mod_mono.so.0.0.0
145511 Feb  5 22:54 /usr/lib64/httpd/modules/mod_mono.so.0.0.0

the mod_mono install seems to have automatically created mod_mono.conf in my httpd/conf folder, but you may want to make sure it's there

vim /etc/httpd/conf/mod_mono.conf

# mod_mono.conf

# Achtung! This file may be overwritten
# Use 'include mod_mono.conf' from other configuration file
# to load mod_mono module.

<IfModule !mod_mono.c>
    LoadModule mono_module /usr/lib64/httpd/modules/mod_mono.so
</IfModule>

<IfModule mod_headers.c>
    Header set X-Powered-By "Mono"
</IfModule>

AddType application/x-asp-net .aspx
AddType application/x-asp-net .asmx
AddType application/x-asp-net .ashx
AddType application/x-asp-net .asax
AddType application/x-asp-net .ascx
AddType application/x-asp-net .soap
AddType application/x-asp-net .rem
AddType application/x-asp-net .axd
AddType application/x-asp-net .cs
AddType application/x-asp-net .vb
AddType application/x-asp-net .master
AddType application/x-asp-net .sitemap
AddType application/x-asp-net .resources
AddType application/x-asp-net .skin
AddType application/x-asp-net .browser
AddType application/x-asp-net .webinfo
AddType application/x-asp-net .resx
AddType application/x-asp-net .licx
AddType application/x-asp-net .csproj
AddType application/x-asp-net .vbproj
AddType application/x-asp-net .config
AddType application/x-asp-net .Config
AddType application/x-asp-net .dll
DirectoryIndex index.aspx
DirectoryIndex Default.aspx
DirectoryIndex default.aspx

Now, you need to get this to work with ISPConfig3, since if you've followed my other tutorials, that's what you have running things on the back end.

Modify your httpd.conf file to include mod_mono.conf. You want to do this at the very bottom, just before the NameVirtualHost directives (ISPConfig puts 3 directives at the very bottom of httpd.conf, you want to place this line just before them:

vim /etc/httpd/conf/httpd.conf

Include /etc/httpd/conf/mod_mono.conf
# this is where ISPConfig's stuff is, don't modify it, this comment is so you know where to put the line above the comment 
NameVirtualHost *:80
NameVirtualHost *:443
Include /etc/httpd/conf/sites-enabled/

now, restart apache

service httpd restart

and open up ISPConfig. go to sites > website > Select the website you want to add a mono enabled directory to, then click on the "Options" tab for that site. Enter the following into the Apache Directives (replace /var/www/path/to/the/web/folder with the path to that site's web folder)

MonoPath default "/opt/mono/lib/mono/2.0"
MonoServerPath default /opt/mono/bin/mod-mono-server
AddMonoApplications default "/test:/var/www/path/to/the/web/folder/test"
<location /test>
	MonoSetServerAlias default
	SetHandler mono
</location>

and finally restart httpd

service httpd restart

here's a test page, create it in your /var/www/path/to/the/web/folder/test directory and set the permissions to whatever the other site's permissions are, or apache.apache

<html>
<body>
<% Response.Write("Hello World!"); %>
</body>
</html>

now, once ISPConfig restarts apache (sometimes this is instant but i've seen it take up to 5 minutes) you'll see Hello World! displayed

So I modified ddclient so that it would update my host's DNS server. My host uses cpanel/WHM which luckily has a JSON API!

Here's how you can make the same modifications:

Install ddclient on your server - this is easy

yum install ddclient

You're also going to need some perl mods:

cpan

note: don't just copy and paste these 4 lines at once, some of the installs may have you type "yes" at some point. In the case of WWW::Mechanize, it forced me to type "yes" at least 4 times.

install JSON
install JSON::XS
install WWW::Mechanize
exit

Now, make sure you have version 3.7.3 of ddclient and then patch it with this ddclient 3.7.3 patch file

cd /tmp
wget http://blog.bennyland.com/wp-content/uploads/2010/01/ddclient.tar.gz
tar -zxvf ddclient.tar.gz
cd ddclient patch -p0 /usr/sbin/ddclient < ddclient.patch

Alternatively you can follow these directions:

vim /usr/sbin/ddclient

require 5.004;
use strict;
use Getopt::Long;
use Sys::Hostname;
use IO::Socket;

require 5.004;
use strict;
use Getopt::Long;
use Sys::Hostname;
use IO::Socket;
use WWW::Mechanize;
use JSON -support_by_pp;

    'sitelutions' => {
        'updateable' => undef,
        'update'     => \&nic_sitelutions_update,
        'examples'   => \&nic_sitelutions_examples,
        'variables'  => merge(
                          { 'server'       => setv(T_FQDNP,  1, 0, 1, 'www.sitelutions.com',   undef)    },
                          { 'min-interval' => setv(T_DELAY,  0, 0, 1, 0, interval('5m')),},
                          $variables{'service-common-defaults'},
                        ),
    },

    'sitelutions' => {
        'updateable' => undef,
        'update'     => \&nic_sitelutions_update,
        'examples'   => \&nic_sitelutions_examples,
        'variables'  => merge(
                          { 'server'       => setv(T_FQDNP,  1, 0, 1, 'www.sitelutions.com',   undef)    },
                          { 'min-interval' => setv(T_DELAY,  0, 0, 1, 0, interval('5m')),},
                          $variables{'service-common-defaults'},
                        ),
    },
    'whm' => {
        'updateable' => undef,
        'update'     => \&nic_whm_update,
        'examples'   => \&nic_whm_examples,
        'variables'  => merge(
                          { 'min-interval' => setv(T_DELAY,  0, 0, 1, interval('5m'), 0),},
                          $variables{'service-common-defaults'},
                        ),
    },

sub split_by_comma {
    my $string = shift;

    return split /\s*[, ]\s*/, $string if defined $string;
    return ();
}

sub split_by_comma {
    my $string = shift;

    return split /\s*[, ]\s*/, $string if defined $string;
    return ();
}
sub split_by_semi {
    my $string = shift;

    return split /\s*[; ]\s*/, $string if defined $string;
    return ();
}

######################################################################
# vim: ai ts=4 sw=4 tw=78 :

######################################################################

######################################################################
## nic_whm_examples
######################################################################
sub nic_whm_examples {
    return <<EoEXAMPLE;

o 'whm'

The 'whm' protocol is an API provided by the cpanel/WHM system.

Configuration variables applicable to the 'whm' protocol are:
  protocol=whm                                   ##
  server=ip.of.your.whm.login  ## defaults to sitelutions.com
  login=service-login          ## login name and password  registered with the service
  password=service-password    ## whm hash used for API (not your whm password)
  host.to.update;host.to.update. #

Example ${program}.conf file entries:
  ## single host update
  protocol=whm,                                                                                                                                 \\
  login=my-whm-login,                                                                                                           \\
  password=a-really-long-hash-string                                            \\
  myhost.com;myhost.com.;subdomain1.myhost.com.;subdomain2.myhost.com.,myotherhost.com;subdomain2.myotherhost.com.

EoEXAMPLE
}
######################################################################
## nic_whm_update
##
## written by Benny Raymond
##
######################################################################
sub nic_whm_update {
    debug("\nnic_whm_update -------------------");
                my $has_failed = 0;
    ## update each configured host
    foreach my $h (@_) {
        my @host_and_names = split_by_semi($h);
        my $host_to_update = $host_and_names[0];
        my %hosts_names;
        undef %hosts_names;
        my $i = 0;
                for (@host_and_names) {
                        if ($i==0) {
                                $i++;
                        } else {
                                $hosts_names{$_} = 1;
                        }
                }
        info("setting IP address to %s for %s", $ip, $host_to_update);
        verbose("UPDATE:","updating %s", $host_to_update);

        my $url_lookup;
        $url_lookup     = "http://$config{$h}{'server'}/json-api/dumpzone";
        $url_lookup .= "?domain=$host_to_update";

        my $api_output = json_whm_fetch($config{$h}{'login'},$config{$h}{'password'},$url_lookup);
        if (!defined($api_output) || !$api_output) {
            failed("updating %s: Could not connect to %s.", $h, $url_lookup);
            last;
        }
        if (json_whm_status($api_output) != 1)
        {
                failed("updating %s: %s - %s", $h, json_whm_status_msg($api_output),  $url_lookup);
        }

        # loop through names and update
        # get the A records
        my(@a_records) = @{(json_whm_a_records($api_output))};
        # and update the DNS table
        foreach (@a_records)
        {
                my(%record) = %{($_)};
                if ($hosts_names{$record{name}})
                {
                    if ($record{address} eq $ip)
                    {
                        success("updating '%s' - '%s': good: IP already set to %s", $host_to_update, $record{name}, $ip);
                    }
                    else
                    {
                                # update this line
                    #    print $record{Line} . ">" . $record{name};
                        $url_lookup     = "http://$config{$h}{'server'}/json-api/editzonerecord";
                        $url_lookup .= "?domain=$host_to_update";
                        $url_lookup .= "&Line=$record{Line}";
                        $url_lookup .= "&address=$ip";
                        my $api_update_output = json_whm_fetch($config{$h}{'login'},$config{$h}{'password'},$url_lookup);

                        if (json_whm_status($api_update_output) != 1)
                        {
                                failed("updating '%s' - '%s': %s %s", $host_to_update, $record{name}, json_whm_status_msg($api_update_output), $url_lookup);
                                $has_failed = 1;
                                $config{$h}{'status'} = 'failed';
                        } else {
                                success("updating '%s' - '%s': good: IP address set to %s", $host_to_update, $record{name}, $ip);
                        }
                     }
                } else {
                        # warning("name '%s' not found for host '%s'", $record{name}, $host_to_update);
                }
        }

        if ($has_failed == 0)
        {
          $config{$h}{'ip'}     = $ip;
          $config{$h}{'mtime'}  = $now;
          $config{$h}{'status'} = 'good';
        }
    }
}
sub json_whm_a_records
{
        my(%json) = %{(shift)};
        my(@records) = @{($json{result}[0]{record})};
        my(@a_records);
        foreach (@records)
        {
                my(%record) = %{($_)};
                if ($record{type} eq "A")
                {
                        push(@a_records, \%record);
                }
        }
        return \@a_records;
}
sub json_whm_status
{
        my(%json) = %{(shift)};
        my $status = $json{result}[0]{status};
        return $status;
}
sub json_whm_status_msg
{
        my(%json) = %{(shift)};
        my $status = $json{result}[0]{statusmsg};
        return $status;
}
sub json_whm_fetch
{
        my ($whm_api_login) = $_[0];
        my ($whm_api_key) = $_[1];
        my ($json_url) = $_[2];
        my $browser = WWW::Mechanize->new();
        my @args = (
                Authorization => "WHM " . $whm_api_login . ":" . $whm_api_key
        );
        my $json_text = "";
        eval{
                # download the json page:
                # print "Getting json $json_url\n";
                $browser->get( $json_url, @args );
                my $content = $browser->content();
                my $json = new JSON;

                # these are some nice json options to relax restrictions a bit:
                $json_text = $json->allow_nonref->utf8->relaxed->escape_slash->loose->allow_singlequote->allow_barekey->decode($content);
        };
        # catch crashes:
        if($@){
                print STDERR "[[JSON ERROR]] JSON parser crashed! $@\n";
                return "";
        } else {
                return $json_text;
        }
}

######################################################################
# vim: ai ts=4 sw=4 tw=78 :

Save and close ddclient

:wq

Now, edit ddclient.conf.

vim /etc/ddclient/ddclient.conf

Here's a simple version (note: you need to log into WHM and get your API key or none of this is going to work. You'll be entering your API key as one line - in WHM it is copied as several lines, just remove the carriage returns and enter it in one huge line as your password). Notice how my domain looks, it's my domain name, followed by a colon, followed by colon seperated hostnames to update - they all have periods after them!

daemon=300                              # check every 300 seconds
syslog=yes                              # log update msgs to syslog
mail=root                               # mail all msgs to root
mail-failure=root                       # mail failed update msgs to root
pid=/var/run/ddclient.pid               # record PID in file.
ssl=yes                                 # use ssl-support.  Works with
                                        # ssl-library
## To obtain an IP address from Web status page (using the proxy if defined)
use=web, web=checkip.dyndns.org/, web-skip='IP Address' # found after IP Address

##
## WHM
##
server=host.or.ip.of.your.whm.maybe.with.port,       \
protocol=whm,                   \
login=your-whm-username,                 \
password=crazy-long-api-key-as-one-long-line               \
hostname.com;hostname.com.;subdomain.hostname.com.

Save and close ddclient.conf

:wq

And finally run it and tell it to run every time the server reboots:

/sbin/chkconfig ddclient on
/sbin/service ddclient start

First, you need to install subversion - it was automatically installed for me already when I installed the OS, however I wanted to update it and found out that I couldn't do so until I deleted the i386 version.

Don't do this step if you're on a 32-bit system!

yum erase subversion.i386

Next, you can install or upgrade subversion and add mod_dav_svn

yum install subversion mod_dav_svn

And Trac...

yum install python
cd /tmp
wget http://peak.telecommunity.com/dist/ez_setup.py
python ez_setup.py
yum install mod_python

MySQL-python is needed for python to interact with mysql. Download the latest MySQL-python from http://sourceforge.net/projects/mysql-python, then:

tar -zxvf mysql-python-tarball.tar.gz
cd mysql-python-source-directory
python setup.py build && python.setup.py install

Some developer packages will also be needed:

yum install neon neon-devel python-devel swig

Next, install clearsilver. You should look for the version that works for your OS. For CentOS 5, it's the latest el5.rf, and either i386 or x86 depending on your setup. You can find the list of packages here: http://dag.wieers.com/rpm/packages/clearsilver/. Make sure that you get the same version number of clearsilver and python-clearsilver.

wget http://dag.wieers.com/rpm/packages/clearsilver/clearsilver-VERSION.el5.rf.ENVIRONMENT.rpm
rpm -i clearsilver-VERSION.el5.rf.ENVIRONMENT.rpm
wget http://dag.wieers.com/rpm/packages/clearsilver/python-clearsilver-VERSION.el5.rf.ENVIRONMENT.rpm
rpm -i python-clearsilver-VERSION.el5.rf.ENVIRONMENT.rpm

Now that you have all of these, you can install Trac. Download the latest tar from http://trac.edgewall.org/wiki/TracDownload

cd /tmp
wget http://path.to/TracDownloadTarball.tar.gz
tar -zxvf TracDownloadTarball.tar.gz
cd TracDownloadTarball
python ./setup.py install

You're done.

Create SVN Repositories and link new Trac projects to them. You'll first make directories to place your svn and trac projects (i'm using /var/www/svn|trac)

mkdir /var/www/svn/svn-repository-name
mkdir /var/www/trac/svn-repository-name
svnadmin create --fs-type fsfs /var/www/svn/svn-repository-name
trac-admin /var/www/trac/
initenv
chown -R apache.apache /var/www/svn/svn-repository-name
chown -R apache.apache /var/www/trac/svn-repository-name

Now you'll need to make a subversion.conf file for apache to load up. One might already exist (it did in my case), but even if it doesn't, that's ok.

vim /etc/httpd/conf.d/subversion.conf

LoadModule dav_svn_module     modules/mod_dav_svn.so
LoadModule authz_svn_module   modules/mod_authz_svn.so
<VirtualHost *:80>
	ServerName svn.astrosmurf.com
	DocumentRoot /path/to/existing/empty/directory
	<Location />
		DAV svn
		SVNParentPath /path/to/svn/root
		SVNListParentPath on
		Order allow,deny
		Allow from all
	</Location>
	<LocationMatch /.+>
		# access differences per repository in here:
		AuthzSVNAccessFile /path/to/svn/root/svn-acl-conf

		# means to authenticate the user
		AuthType Basic
		AuthName "Astrosmurf Subversion"
		AuthUserFile /path/to/svn/root/svn.htpasswd

		# only authenticated users may access the repository
		Require valid-user
	</LocationMatch>
	ErrorLog /var/www/logs/error.svn.log
	CustomLog /var/www/logs/access.svn.log combined
</VirtualHost>

You'll also want to do the same for Trac

vim /etc/httpd/conf.d/trac.conf

and the contents should look similar to this (of course, modify both of these to suit your needs):

<IfModule mod_python.c>
	<VirtualHost *:80>
		ServerName trac.yourserver.com
		DocumentRoot /path/to/existing/empty/directory
		<Location />
			SetHandler mod_python
			PythonInterpreter main_interpreter
			PythonHandler trac.web.modpython_frontend
			PythonOption TracEnvParentDir /path/to/trac/root
			PythonOption TracUriRoot /
			PythonOption PYTHON_EGG_CACHE /usr/lib/trac/plugins-cache
			Order allow,deny
			Allow from all
		</Location>
		<LocationMatch /[^/P]+/.*>
			# means to authenticate the user
			AuthType Basic
			AuthName "Subversion"
			AuthUserFile /path/to/svn/root/svn.htpasswd
			AuthGroupFile /path/to/svn/root/svn-authgroup-conf
			# only authenticated users may access the repository
			Require group staff
		</LocationMatch>
		<LocationMatch /Pub[^/]+/.*>
			# means to authenticate the user
			AuthType Basic
			AuthName "Subversion"
			AuthUserFile /path/to/svn/root/svn.htpasswd
			# only authenticated users may access the repository
			Require valid-user
		</LocationMatch>

		ErrorLog /var/www/logs/error.trac.log
		CustomLog /var/www/logs/access.trac.log combined
	</VirtualHost>
</IfModule>

Now, make the different auth files. This file contains users and groups... in fact I don't remember why i have both the acl and the authgroup file, but whatever...

vim /var/www/svn/svn-acl-conf

[groups]
staff = user1, user2, user3
rb = reviewboard

[/]
@rb = rw

[name_of_staff_repo:/]
@staff = rw

[name_of_user1_repo:/]
user1 = rw

[Public:/]
@staff = rw
public = r

and set up authgroup. This file contains group names and who belongs to them

vim /var/www/svn/svn-authgroup-conf

staff: user1 user2 user3

And the passwords file

touch /var/www/svn/svn.htpasswd
htpasswd -m /var/www/svn/svn.htpasswd user1
htpasswd -m /var/www/svn/svn.htpasswd user2
htpasswd -m /var/www/svn/svn.htpasswd user3

You can also create a public user and somehow let the public know that they can enter your repository with username public and password public.

htpasswd -m /var/www/svn/svn.htpasswd public

Restart httpd and you should should now be able to go to http://svn.yourhost.com/ and http://trac.yourhost.com/

service httpd restart

A lot of this info came from several different sources, some from googling and others form these places:

• http://biotext.org.uk/updating-subversion-on-64-bit-linux-centos-5/
• http://www.daniel-skinner.co.uk/setup-subversion-and-trac-on-centos-5/06/01/2008
• http://www.techyouruniverse.com/software/installing-trac-with-subversion-on-cent-os-5-with-neon-and-quicksilver

Setting up Postfix to use your ISP's smtp

Note: if your ISP requires authentication for smtp, you'll have to do some googleing.  If they don't (mine doesn't) then this will work fine for you.

vim /etc/postfix/main.cf

Next, you need to add the relayhost variable, you may have to enclose the domain in brackets, I didn't have to but I've read everywhere that you should:

relayhost = [your.isps.smtp.com]

Other items to potentially edit:

myhostname = your.host.name
mydomain = your.domain
myorigin = $mydomain
inet_interfaces = all
mydestination = $myhostname, localhost.$mydomain, localhost
unknown_local_recipient_reject_code = 550
relay_domains = $mydestination

Now, restart postfix

service postfix reload

Forwarding name@yourdomain.com to a real e-mail address

First things first, you need to edit main.cf

vim /etc/postfix/main.cf

Next, either add or edit the following lines. You can add as many domains as you want. If you followed the Perfect Server tutorial, you'll have all sorts of junk in these variables, just replace them.

virtual_alias_domains = yourdomain.com yourotherdomain.com.
virtual_alias_maps = hash:/etc/postfix/virtual

Now, edit the /etc/postfix/virtual file to add your forward rules:

vim /etc/postfix/virtual

forward all mail sent to *@yourdomain.com to your@email.com and name@yourotherdomain.com to your@email.com:

@yourdomain.com your@email.com
name@yourotherdomain.com your@email.com

Now, restart postfix

postmap /etc/postfix/virtual
service postfix reload