ssh root@yourbox.com
cd

yum -y groupinstall 'Development Tools'
yum -y install bzip* zlib* libtif* libjpeg* freetype* tkinter

wget http://effbot.org/downloads/Imaging-1.1.7.tar.gz
tar xfz Imaging-1.1.7.tar.gz && rm -f Imaging-1.1.7.tar.gz

cd Imaging-1.1.7
python setup.py build_ext -i

python selftest.py
python setup.py install

ssh root@yourbox.com
cd
useradd sally
passwd sally

wget http://packages.sw.be/rpmforge-release/rpmforge-release-0.5.1-1.el5.rf.x86_64.rpm
rpm -Uhv rpmforge-release-0.5.1-1.el5.rf.x86_64.rpm

yum -y update

yum install -y freenx

yum -y groupinstall "X Window System" "GNOME Desktop Environment"

class Cache(object):
   """
   Used to cache resources which take a long time to load or allocate.  It
   uses a "most-recently-used" method to determine what remains in cache.
   Whenever something is used, it is promoted to the youngest generation.
   Every "frequency" calls to the cache, the oldest generation is dropped
   and all generations are aged by one.
 
   The limitation of this approach is that it does not deal well with
   resources of highly variable size or load speed:
   * Since cache size is limited by the number of uses rather than
     directly by cache size, a very large resource might create a larger
     cache than is desireable.  As a result, the frequency must be set
     low to account for even a single large resource, causing
     undercaching.
   * Resources which take longer to load should generally be kept in cache
     longer because caching them provides the greatest benefit.  This cache
     does not account for the time it takes to load at all.
 
   To deal with these limitations, the user can define their own Ager, an
   object that determines when to age the cache.  This must define an
   age(cache) method which takes a cache and returns True if it needs to
   be cached, and a reset(cache) method which resets the ager after the
   cache has been aged or cleared.
 
   cache.age() can be called to manually age the cache, and cache.clear()
   can be called to clear it.
   """
   class Ager(object):
      def __init__(self,frequency = 25):
         self.frequency = frequency
         self.count = 0
      def age(self,cache):
         self.count += 1
         if self.count == self.frequency:
            self.count = 0
            return True
         return False
      def reset(self,cache):
         self.count = 0
   def __init__(self,load,ager = Cache.Ager()):
      self.load = load
      self.cache = [{}] * 5
      self.ager = ager
   def __getitem__(self,key):
      self.count += 1
      for generation in self.cache:
         if key in generation:
            value = generation[key]
            if not generation is self.cache[0]:
               self.cache[0][key] = value
            if self.ager.age(self):
               self.age()
            return value
      value = load(key)
      self.cache[0][key] = value
      if self.ager.age(self):
         self.age()
      return value
   def age(self):
      self.cache = [{}] + self.cache[:-1]
      self.ager.reset(self)
   def clear(self):
      self.cache = [{}] * len(self.cache)
      self.ager.reset(self)

ssh root@yourbox.com
cd

cd
wget http://packages.sw.be/rpmforge-release/rpmforge-release-0.5.1-1.el5.rf.x86_64.rpm
rpm -Uhv rpmforge-release-0.5.1-1.el5.rf.x86_64.rpm

yum -y groupinstall 'Development Tools'
yum-y  install openssl-devel* zlib*.x86_64

wget http://sqlite.org/sqlite-amalgamation-3.7.3.tar.gz
wget http://python.org/ftp/python/2.7/Python-2.7.tgz
wget http://pypi.python.org/packages/2.7/s/setuptools/setuptools-0.6c11-py2.7.egg

cd
tar xfz sqlite-amalgamation-3.7.3.tar.gz
cd sqlite-3.7.3/
./configure
make
make install

cd
tar xfz Python-2.7.tgz
cd Python-2.7
./configure --prefix=/opt/python2.7 --with-threads --enable-shared
make
make install

su - root
cd
nano .bash_profile
# add the following lines to the bottom of the file
alias python='/opt/python2.7/bin/python'
alias python2.7='/opt/python2.7/bin/python'
PATH=$PATH:/opt/python2.7/bin
# 'ctrl + o' to save the file and 'ctrl+x' to close the file
# now do the same for every other user, like this:
nano /home/usera/.bash_profile
# add the following lines to the bottom of the file
alias python='/opt/python2.7/bin/python'
alias python2.7='/opt/python2.7/bin/python'
PATH=$PATH:/opt/python2.7/bin
# 'ctrl + o' to save the file and 'ctrl+x' to close the file

su - root
cd
cat >> /etc/ld.so.conf.d/opt-python2.7.conf
-->/opt/python2.7/lib	#hit 'enter' and then 'ctrl+d'
ldconfig

cd
sh setuptools-0.6c11-py2.7.egg
cd /opt/python2.7/lib/python2.7/config
ln -s ../../libpython2.7.so .

import sys
import os
import re
import hotshot, hotshot.stats
import tempfile
import StringIO
 
from django.conf import settings
 
 
words_re = re.compile( r'\s+' )
 
group_prefix_re = [
    re.compile( "^.*/django/[^/]+" ),
    re.compile( "^(.*)/[^/]+$" ),
    re.compile( ".*" ),
]
 
class ProfileMiddleware(object):
    def process_request(self, request):
        if (settings.DEBUG or request.user.is_superuser) and 'lookie' in request.GET:
            self.tmpfile = tempfile.mktemp()
            self.prof = hotshot.Profile(self.tmpfile)
 
    def process_view(self, request, callback, callback_args, callback_kwargs):
        if (settings.DEBUG or request.user.is_superuser) and 'lookie' in request.GET:
            return self.prof.runcall(callback, request, *callback_args, **callback_kwargs)
 
    def get_group(self, file):
        for g in group_prefix_re:
            name = g.findall( file )
            if name:
                return name[0]
 
    def get_summary(self, results_dict, sum):
        list = [ (item[1], item[0]) for item in results_dict.items() ]
        list.sort( reverse = True )
        list = list[:40]
 
        res = "      tottime\n"
        for item in list:
            res += "%4.1f%% %7.3f %s\n" % ( 100*item[0]/sum if sum else 0, item[0], item[1] )
 
        return res
 
    def summary_for_files(self, stats_str):
        stats_str = stats_str.split("\n")[5:]
 
        mystats = {}
        mygroups = {}
 
        sum = 0
 
        for s in stats_str:
            fields = words_re.split(s);
            if len(fields) == 7:
                time = float(fields[2])
                sum += time
                file = fields[6].split(":")[0]
 
                if not file in mystats:
                    mystats[file] = 0
                mystats[file] += time
 
                group = self.get_group(file)
                if not group in mygroups:
                    mygroups[ group ] = 0
                mygroups[ group ] += time
 
        return "<pre>" + \
               " ---- By file ----\n\n" + self.get_summary(mystats,sum) + "\n" + \
               " ---- By group ---\n\n" + self.get_summary(mygroups,sum) + \
               "</pre>"
 
    def process_response(self, request, response):
        if (settings.DEBUG or request.user.is_superuser) and 'lookie' in request.GET:
            self.prof.close()
 
            out = StringIO.StringIO()
            old_stdout = sys.stdout
            sys.stdout = out
 
            stats = hotshot.stats.load(self.tmpfile)
            stats.sort_stats('time', 'calls')
            stats.print_stats()
 
            sys.stdout = old_stdout
            stats_str = out.getvalue()
 
            if response and response.content and stats_str:
                response.content = "<pre>" + stats_str + "</pre>"
 
            response.content = "\n".join(response.content.split("\n")[:40])
 
            response.content += self.summary_for_files(stats_str)
 
            os.unlink(self.tmpfile)
 
        return response

    def flattenlist(L):
        import types
        WhiteTypes = ('StringType', 'UnicodeType', 'StringTypes', 'ListType', 'ObjectType', 'TupleType')
        BlackTypes= tuple( [getattr(types, x) for x in dir(types) if not x.startswith('_') and x not in whites] )
 
        tmp = []
        def core(L):
            if  not hasattr(L,'__iter__'):
                return [L]
            else :
                for i in L:
                    if isinstance(i,BlackTypes):
                        tmp.append(i)
                        continue
                    if type(i) == type(str()):
                        tmp.append(i)
                    else:
                        core(i)
            return tmp
        return core(L)

#include "Python.h"
#include <dystopia.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
 
static PyObject *
put(PyObject *self,PyObject *args){
    const char *dbname;
    const char *stext;
    const int *kid;
    int ecode;
    bool result;
    TCIDB *idb;
    if (!PyArg_ParseTuple(args, "sis", &amp;dbname, &amp;kid, &amp;stext))
        return NULL;
    /* create the object */
    idb = tcidbnew();
    /* open the database */
    if(!tcidbopen(idb, dbname, IDBOCREAT | IDBOWRITER)){
        ecode = tcidbecode(idb);
        fprintf(stderr, "open error: %s\n", tcidberrmsg(ecode));
    }
    result = tcidbput(idb,(int64_t)kid,stext);
    /* close the database */
    if(!tcidbclose(idb)){
        ecode = tcidbecode(idb);
        fprintf(stderr, "close error: %s\n", tcidberrmsg(ecode));
    }
    /* delete the object */
    tcidbdel(idb);
    return Py_BuildValue("b",result);
}
 
static PyObject *
search(PyObject *self, PyObject *args){
    const char *stext;
    const char *dbname;
    TCIDB *idb;
    int ecode, rnum, i;
    uint64_t *result;
    char *text;
    PyObject* pList;
 
    if (!PyArg_ParseTuple(args, "ss", &amp;dbname, &amp;stext))
        return NULL;
 
    /* create the object */
    idb = tcidbnew();
 
    /* open the database */
    if(!tcidbopen(idb, dbname, IDBOREADER | IDBONOLCK)){
        ecode = tcidbecode(idb);
        fprintf(stderr, "open error: %s\n", tcidberrmsg(ecode));
    }
    /* search records */
    result = tcidbsearch2(idb, stext, &amp;rnum);
    pList = PyList_New(rnum);
    if(result){
        for(i = 0; i < rnum; i++){
            // printf("r[i]:%lld\n",result[i]);
            PyList_SetItem(pList, i, Py_BuildValue("i", (int)result[i]));
        }
        tcfree(result);
    } else {
        ecode = tcidbecode(idb);
        fprintf(stderr, "search error: %s\n", tcidberrmsg(ecode));
    }
 
    /* close the database */
    if(!tcidbclose(idb)){
        ecode = tcidbecode(idb);
        fprintf(stderr, "close error: %s\n", tcidberrmsg(ecode));
    }
 
    /* delete the object */
    tcidbdel(idb);
 
    return Py_BuildValue("O",pList);
}
 
PyMethodDef methods[] = {
  {"search", search, METH_VARARGS},
  {"put", put, METH_VARARGS},
  {NULL, NULL},
};
 
void initpykhufu(){
    PyObject* m;
    m = Py_InitModule("pykhufu", methods);
}

#!/bin/bash
#*** SET ME FIRST ***#
NASUSER="Your-User-Name"
NASPASS="Your-Password"
NASIP="nas.yourcorp.com"
NASROOT="/username"
NASMNTPOINT="/mnt/nas"
EMAILID="admin@yourcorp.com"
#*** END SET ME ***#
 
GETNASIP=$(host ${NASIP} | awk '{ print $4}')
 
# Default warning limit is set to 17GiB
LIMIT="17"
 
# Failsafe
[ ! -d ${NASMNTPOINT} ] && mkdir -p ${NASMNTPOINT}
mount | grep //${GETNASIP}/${NASUSER}
 
# if not mounted, just mount nas
[ $? -eq 0 ] && : || mount -t cifs //${NASIP}/${NASUSER} -o username=${NASUSER},password=${NASPASS} ${NASMNTPOINT}
cd ${NASMNTPOINT}
 
# get NAS disk space
nSPACE=$(du -hs|cut -d'G' -f1)
# Bug fix
# get around floating point by rounding off e.g 5.7G stored in $nSPACE
# as shell cannot do floating point
SPACE=$(echo $nSPACE | cut -d. -f1)
 
cd /
umount ${NASMNTPOINT}
 
# compare and send an email
if [ $SPACE -ge $LIMIT ]
then
        logger "Warning: NAS Running Out Of Disk Space [${SPACE} G]"
        mail -s 'NAS Server Disk Space' ${EMAILID} <<EOF
NAS server [ mounted at $(hostname) ] is running out of disk space!!!
Current allocation ${SPACE}G @ $(date)
EOF
else
    logger "$(basename $0) ~ NAS server ${NASIP} has sufficent disk space for backup!"
fi

#!/usr/bin/env python
 
#
#     all modules in the stdlib
#
 
import socket
import sys
import thread
 
def main(setup, error):
    sys.stderr = file(error, 'a')
    for settings in parse(setup):
        thread.start_new_thread(server, settings)
    lock = thread.allocate_lock()
    lock.acquire()
    lock.acquire()
 
def parse(setup):
    settings = list()
    for line in file(setup):
        parts = line.split()
        settings.append((parts[0], int(parts[1]), int(parts[2])))
    return settings
 
def server(*settings):
    try:
        dock_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        dock_socket.bind(('', settings[2]))
        dock_socket.listen(5)
        while True:
            client_socket = dock_socket.accept()[0]
            server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            server_socket.connect((settings[0], settings[1]))
            thread.start_new_thread(forward, (client_socket, server_socket))
            thread.start_new_thread(forward, (server_socket, client_socket))
    finally:
        thread.start_new_thread(server, settings)
 
def forward(source, destination):
    string = ' '
    while string:
        string = source.recv(1024)
        if string:
            destination.sendall(string)
        else:
            source.shutdown(socket.SHUT_RD)
            destination.shutdown(socket.SHUT_WR)
 
if __name__ == '__main__':
    main('proxy.cfg', 'error.log')