------------------------------------------------------------
Server listening on TCP port 5001
TCP window size: 85.3 KByte (default)
------------------------------------------------------------
[  4] local x port 5001 connected with x port 64183
[ ID] Interval       Transfer     Bandwidth
[  4]  0.0-10.0 sec  61.7 MBytes  51.7 Mbits/sec
[  5] local x port 5001 connected with x port 64184
[  5]  0.0-10.0 sec  1.07 GBytes    921 Mbits/sec

------------------------------------------------------------
Client connecting to x, TCP port 5001
TCP window size:   129 KByte (default)
------------------------------------------------------------
[  3] local x port 64183 connected with x port 5001
[ ID] Interval       Transfer     Bandwidth
[  3]  0.0-10.0 sec  61.7 MBytes  51.8 Mbits/sec

#!/bin/sh
 
if [ $# -ne 2 ]
then
	echo "Usage: $0 <postgresql sql dump> <db_name>" >&2
	exit 1
fi
 
db_file=$1
db_name=$2
 
if [ ! -f $db_file -o ! -r $db_file ]
then
	echo "error: $db_file not found or not readable" >&2
	exit 2
fi
 
grep -b "^\connect" $db_file | grep -m 1 -A 1 "$db_name$" | while read line
do
	bytes=`echo $line | cut -d: -f1`
 
	if [ -z "$start_point" ]
	then
		start_point=$bytes
	else
		end_point=$bytes
	fi
done
 
if [ -z "$start_point" -o -z "$end_point" ]
then
	echo "error: start or end not found" >&2
	exit 3
fi
 
db_length=`expr $end_point - $start_point`
 
tail -c +$start_point $db_file | head -c $db_length | tail +3

import os, sys, re
from os.path import join, getsize, exists
 
def median(numbers):
    s = sorted(numbers)
    l = len(numbers)
    if l % 2 == 0:
        a, b = s[l / 2 - 1 : l / 2 + 1]
        if a != b:
            return a + b / 2.0
        else:
            return a
    else:
        return s[l / 2]
 
sizes = []
req_re = None
target = '.'
 
if len(sys.argv) > 1:
    target = sys.argv[1]
 
if len(sys.argv) == 3:
    req_re = re.compile(sys.argv[2])
 
for root, dirs, files in os.walk(target):
    for name in files:
        absp = join(root, name)
        if exists(absp):
            if not req_re or req_re.search(absp):
                sizes.append(getsize(absp))
 
num = len(sizes)
total = sum(sizes)
 
print "Num files: %d" % num
print "Average  : %0.2f KB" % ((total / num) / 1024.0)
print "Median   : %0.2f KB" % (median(sizes) / 1024.0)
print "Min      : %0.2f KB" % (min(sizes) / 1024.0)
print "Max      : %0.2f KB" % (max(sizes) / 1024.0)

property FLUSH_TEXT : "Quit and flush"
property SET_TEXT : "Set speed"
 
-- be damn carefull what you input here, it will run as root
on ipfwLimit(bandwidth)
	my ipfwFlush()
 
	do shell script "ipfw pipe 1 config bw " & bandwidth & "KB" with administrator privileges
	do shell script "ipfw add 10 pipe 1 tcp from any 80 to me" with administrator privileges
	do shell script "ipfw add 11 pipe 1 tcp from me to any 80" with administrator privileges
end ipfwLimit
 
-- flush any ipfw rules
on ipfwFlush()
	do shell script "ipfw -f flush" with administrator privileges
end ipfwFlush
 
on main()
	set question to display dialog "Control your http traffic speed" buttons {FLUSH_TEXT, SET_TEXT} default button 2
	set answer to button returned of question
 
	if answer is equal to FLUSH_TEXT then
		my ipfwFlush()
	end if
 
	if answer is equal to SET_TEXT then
		set bandwidth_question to display dialog "Enter bandwidth in KB/s (don't do something stupid like entering "; rm -rf /)" default answer "56"
		set bandwidth to text returned of bandwidth_question
 
		my ipfwLimit(bandwidth)
 
		my main()
	end if
end main
 
my main()

$ file `which python`
/usr/bin/python: Mach-O universal binary with 3 architectures
/usr/bin/python (for architecture x86_64):	Mach-O 64-bit executable x86_64
/usr/bin/python (for architecture i386):	Mach-O executable i386
/usr/bin/python (for architecture ppc7400):	Mach-O executable ppc
$ file `which python2.5`
/usr/bin/python2.5: Mach-O universal binary with 2 architectures
/usr/bin/python2.5 (for architecture i386):	Mach-O executable i386
/usr/bin/python2.5 (for architecture ppc7400):	Mach-O executable ppc

$ cd /opt/local/var/macports/sources/rsync.macports.org/release/ports/databases/postgresql81
$ curl -s http://trac.macports.org/raw-attachment/ticket/14619/combined_updated_universal.patch | sudo patch
$ sudo mkdir files/
$ sudo mv ld.sh files/
$ sudo mv patch_pg_config_h files/

$ sudo port install postgresql81 +universal

$ wget http://initd.org/pub/software/psycopg/psycopg2-2.0.12.tar.gz
$ tar zxf psycopg2-2.0.12.tar.gz
$ cd psycopg2-2.0.12
$ sudo python2.5 setup.py install
$ sudo python2.5 setup.py clean
$ sudo python2.6 setup.py install

mads@workmads ~ % cat .ssh/config
ServerAliveInterval 60

def http_head(url):
    import httplib
    import urlparse
 
    redirects = 0
 
    while redirects < 10:
        scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
 
        if scheme == 'https':
            conn = httplib.HTTPSConnection(netloc)
        else:
            conn = httplib.HTTPConnection(netloc)
 
        conn.request("HEAD", "%s%s%s%s%s" % (path, query and "?" or "", query,
                                             fragment and "#" or "", fragment))
 
        res = conn.getresponse()
 
        if res.status in (301, 302) and res.getheader('location'):
            url = res.getheader('location')
            redirects += 1
        else:
            break
 
    return res.status, res.reason

xmllint --format <file>

 
def send_plain_mail(subject, body, from_mail, to):
    import smtplib
    from email.MIMEText import MIMEText
    from email.Encoders import encode_quopri
 
    msg = MIMEText(body, 'plain', 'iso-8859-1')
 
    msg['Subject'] = subject
    msg['From'] = from_mail
    msg['To'] = to
 
    s = smtplib.SMTP()
    s.connect()
    s.sendmail(from_mail, [to], msg.as_string())
    s.close()

import os
import subprocess
import threading
 
from Queue import Queue
 
ITUNES_DIR = os.path.expanduser("~/Music/iTunes/iTunes Music/")
KNOWN_EXTENSIONS = ('.mp3', '.aac')
AACGAIN_PARAMS = ['-a', '-k', '-d', '3']
AACGAIN_LOCATION = 'aacgain'
 
def get_files():
    """
    A generator that returns tuples with album name and a list of mp3 files.
    """
    for root, dirs, files in os.walk(ITUNES_DIR):
        files = filter(lambda x: os.path.splitext(x)[1] in KNOWN_EXTENSIONS, files)
        if files:
            yield [os.path.join(root, f) for f in files]
 
def get_num_cpus():
    """
    Returns the number of cpus in the machine, and 1 on failure.
    """
    try:
        return int(subprocess.Popen(['sysctl', '-n', 'hw.ncpu'], stdout=subprocess.PIPE).communicate()[0].strip())
    except:
        return 1
 
def run_aacgain(queue):
    """
    Returns a callable that will be called inside a thread.
    """
    def callable():
        try:
            while True:
                files = queue.get()
 
                if files is None:
                    break
 
                p = subprocess.Popen([AACGAIN_LOCATION] + AACGAIN_PARAMS + files)
                p.wait()
        except KeyboardInterrupt:
            pass
    return callable
 
queue = Queue()
workers = []
 
for i in range(get_num_cpus()):
    worker = threading.Thread(target=run_aacgain(queue))
    worker.start()
 
    workers.append(worker)
 
for album_files in get_files():
    queue.put(album_files)
 
for i in range(get_num_cpus()):
    queue.put(None)