@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+
+
+import re
+from collections import defaultdict, namedtuple
+
+format_pat= re.compile( 
+    r"(?P<host>[\d\.]+)\s" 
+    r"(?P<identity>\S*)\s" 
+    r"(?P<user>\S*)\s"
+    r"\[(?P<time>.*?)\]\s"
+    r'"(?P<request>.*?)"\s'
+    r"(?P<status>\d+)\s"
+    r"(?P<bytes>\S*)\s"
+    r'"(?P<referer>.*?)"\s' # [SIC]
+    r'"(?P<user_agent>.*?)"\s*' 
+)
+
+Access = namedtuple('Access',
+    ['host', 'identity', 'user', 'time', 'request',
+    'status', 'bytes', 'referer', 'user_agent'] )
+
+def access_iter( source_iter ):
+    for log in source_iter:
+        for line in (l.rstrip() for l in log):
+            match= format_pat.match(line)
+            if match:
+                yield Access( **match.groupdict() )
@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+
+import sys
+
+def dict_logline(line):
+	split_line = line.split()
+	return {'remote_host': split_line[0],
+	        'status': split_line[8],
+	        'bytes_sent': split_line[9]
+	        }
+
+def generate_log_report(logfile):
+	report_dict = {}
+	for line in logfile:
+		line_dict = dict_logline(line)
+		print line_dict
+		try:
+			bytes_sent = int(line_dict['bytes_sent'])
+		except ValueError:
+			continue
+		report_dict.setdefault(line_dict['remote_host'], []).append(bytes_sent)
+	return report_dict
+
+if __name__ == "__main__":
+	if not len(sys.argv) > 1 :
+		print __doc__
+		sys.exit(1)
+	infile_name = sys.argv[1]
+	try:
+		infile = open(infile_name, 'r')
+	except IOerror:
+		print __doc__
+		sys.exit[1]
+
+log_report = generate_log_report(infile)
+print log_report
+infile.close()
+
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+import sys
+import time
+import socket
+from threading import Thread
+
+host = '184.173.198.48'
+port = 80
+
+thread_count = 10  
+
+class Controller:
+    def __init__(self):
+        self.count_ref = []
+    def start(self):
+        for i in range(thread_count):
+            agent = Agent(self.count_ref)
+            agent.setDaemon(True)
+            agent.start()
+        print 'started %d threads' % (i + 1)
+        while True:
+            time.sleep(1)
+            line = 'connects/sec: %s' % len(self.count_ref)
+            self.count_ref[:] = []
+            sys.stdout.write(chr(0x08) * len(line))
+            sys.stdout.write(line)
+            
+class Agent(Thread):
+    def __init__(self, count_ref):
+        Thread.__init__(self)
+        self.count_ref = count_ref
+    def run(self):
+        while True:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            try:
+                s.connect((host, port))
+                s.shutdown(2)
+                s.close()
+                self.count_ref.append(1)
+            except:
+                print 'SOCKET ERROR\n'
+                
+if __name__ == '__main__':
+    controller = Controller()
+    controller.start()
+
@@ -0,0 +1,25 @@
+#!/usr/bin/python
+
+import random
+import urllib
+
+def list2String(x):
+ """ from a list like [1,2,5]
+     return a string like '1,2,5' """
+ data = ""
+ for i in x:
+  data += str(i)+","
+ return data[0:len(data)-1]
+
+def makeChart(x,y,filename):
+ query_url = "http://chart.apis.google.com/chart?chxt=x,y&chs=300x200&cht=s&chd=t:"
+ query_url += list2String(x)+"|"+list2String(y)
+ chart = urllib.urlopen(query_url) # retrieve the chart
+ print "saving",query_url
+ f = open(filename,"wb")
+ f.write(chart.read()) # save the pic
+ f.close()
+
+x = random.sample(range(0,100),10) # list with
+y = random.sample(range(0,100),10) # random values in [0 100[
+makeChart(x,y,"chart.png")
@@ -0,0 +1,11 @@
+import urllib2
+import sys
+
+def internet_on():
+    try:
+     response = urllib2.urlopen('http://google.com', timeout = 3)
+     print True
+    except urllib2.URLError as err: 
+          pass
+          print False
+internet_on()
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+# cpu graph (needs gnu/linux, grep, top, tail)
+# 2009 mennonite
+# public domain
+import os
+import time
+while True:
+    f = os.system("top -n 2 | grep -i cpu\(s\) | tail -1 > /tmp/cpugr")
+    f = open("/tmp/cpugr")
+    ff = f.readlines()
+    f.close()
+    f = os.system("rm /tmp/cpugr")
+    f = "".join(ff)
+    ff = f.split("\x1b[") # clean up some of the ansi codes
+    f = "".join(ff)
+    f = f[:f.find("us")] # left of "us"
+    f = f[:f.find(".")] # left of "."
+    f = f[f.rfind(" "):] # right of bsearch " "
+    f = int(float(int(f)) * 4 / 5) # 80 / 100... 100% = 80 columns
+    ff = f
+    if f < 0: f = 0
+    if f > 79: f = 79 
+    print "]" * f
+    time.sleep(1)
@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+import time
+
+TIMEFORMAT = "%m/%d/%y %H:%M:%S"
+INTERVAL = 2
+
+def getTimeList():
+    statFile = file("/proc/stat", "r")
+    timeList = statFile.readline().split(" ")[2:6]
+    statFile.close()
+    for i in range(len(timeList))  :
+        timeList[i] = int(timeList[i])
+    return timeList
+
+def deltaTime(interval)  :
+    x = getTimeList()
+    time.sleep(interval)
+    y = getTimeList()
+    for i in range(len(x))  :
+        y[i] -= x[i]
+    return y
+
+if __name__ == "__main__"  :
+    while True  :
+        dt = deltaTime(INTERVAL)
+        timeStamp = time.strftime(TIMEFORMAT)
+        cpuPct = 100 - (dt[len(dt) - 1] * 100.00 / sum(dt))
+        print timeStamp + "\t" + str('%.4f' %cpuPct)  
@@ -0,0 +1,27 @@
+#!/usr/bin/python
+
+import psutil as ps
+
+class cpu_percent:
+
+    def __init__(self):
+        self.last = ps.cpu_times()
+
+    def update(self):
+
+        last = self.last
+        current = ps.cpu_times()
+
+        total_time_passed = sum([current.__dict__.get(key, 0) - last.__dict__.get(key, 0) for key in current.attrs])
+
+        sys_time = current.system - last.system
+        usr_time = current.user - last.user
+
+        self.last = current
+
+        if total_time_passed > 0:
+            sys_percent = 100 * sys_time / total_time_passed
+            usr_percent = 100 * usr_time / total_time_passed
+            return sys_percent + usr_percent
+        else:
+            return 0
@@ -0,0 +1,148 @@
+#!/usr/bin/python
+
+import socket
+import struct
+import StringIO
+
+# OCTET 1,2 	ID 
+# OCTET 3,4	QR(1 bit) + OPCODE(4 bit)+ AA(1 bit) + TC(1 bit) + RD(1 bit)+ RA(1 bit) + 
+# 		Z(3 bit) + RCODE(4 bit)
+# OCTET 5,6	QDCOUNT 
+# OCTET 7,8	ANCOUNT	
+# OCTET 9,10	NSCOUNT	
+# OCTET 11,12	ARCOUNT
+
+class DnsHeader:
+	def __init__(self):
+		self.id = 0x1234
+		self.bits = 0x0100 # recursion desired
+		self.qdCount = 0
+		self.anCount = 0
+		self.nsCount = 0
+		self.arCount = 0
+	def toBinary(self):
+		return struct.pack('!HHHHHH',
+			self.id,
+			self.bits,
+			self.qdCount,
+			self.anCount,
+			self.nsCount,
+			self.arCount);
+	def fromBinary(self, bin):
+		if bin.read:
+			bin = bin.read(12)
+		(self.id,
+		 self.bits,
+		 self.qdCount,
+		 self.anCount,
+		 self.nsCount,
+		 self.arCount) = struct.unpack('!HHHHHH', bin)
+		return self
+	def __repr__(self):
+		return '<DnsHeader %d, %d questions, %d answers>' % (self.id, self.qdCount, self.anCount)
+
+class DnsResourceRecord:
+	pass
+
+class DnsAnswer(DnsResourceRecord):
+	pass
+
+class DnsQuestion:
+	def __init__(self):
+		self.labels = []
+		self.qtype = 1  # A-record
+		self.qclass = 1 # the Internet
+	def toBinary(self):
+		bin = '';
+		for label in self.labels:
+			assert len(label) <= 63
+			bin += struct.pack('B', len(label))
+			bin += label
+		bin += '\0' # Labels terminator
+		bin += struct.pack('!HH', self.qtype, self.qclass)
+		return bin
+
+class DnsPacket:
+	def __init__(self, header = None):
+		self.header = header
+		self.questions = []
+		self.answers = []
+	def addQuestion(self, question):
+		self.header.qdCount += 1
+		self.questions.append(question)
+	def toBinary(self):
+		bin = self.header.toBinary()
+		for question in self.questions:
+			bin += question.toBinary()
+		return bin
+	def __repr__(self):
+		return '<DnsPacket %s>' % (self.header)
+
+class BinReader(StringIO.StringIO):
+	def unpack(self, fmt):
+		size = struct.calcsize(fmt)
+		bin = self.read(size)
+		print bin.encode('hex')
+		return struct.unpack(fmt, bin)
+
+class DnsPacketConverter:
+	def fromBinary(self, bin):
+		reader = BinReader(bin)
+		header = DnsHeader().fromBinary(reader)
+		packet = DnsPacket(header)
+		for qi in range(header.qdCount):
+			q = self.readQuestion(reader)
+			packet.questions.append(q)
+		for ai in range(header.anCount):
+			a = self.readAnswer(reader)
+			packet.answers.append(a) 
+		return packet
+	def readQuestion(self, reader):
+		question = DnsQuestion()
+		question.labels = self.readLabels(reader)
+		(question.qtype, question.qclass) = reader.unpack('!HH')
+		return question
+	def readAnswer(self, reader):
+		print "reading answer"
+		answer = DnsAnswer()
+		answer.name = self.readLabels(reader)
+		(type, rrclass, ttl, rdlength) = reader.unpack('!HHiH')
+		answer.rdata = reader.read(rdlength)
+		print answer.rdata
+	def readLabels(self, reader):
+		labels = []
+		while True:
+			(length,) = reader.unpack('B')
+			if length == 0: break
+			# TODO suppport compression
+			label = reader.read(length)
+			labels.append(label)
+		return labels
+	
+
+
+if __name__ == '__main__':
+	header = DnsHeader()
+	bin = header.toBinary()
+	print 'header', bin.encode('hex')
+
+	question = DnsQuestion()
+	question.labels = ['google', 'com']
+	print 'question', question.toBinary().encode('hex')
+
+	packet = DnsPacket(header)
+	packet.addQuestion(question)
+	print 'packet', packet.toBinary().encode('hex')
+
+	sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+	sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+	# dest = ('127.0.0.1', 5353)
+	dest = ('8.8.4.4', 53)
+	sock.sendto(packet.toBinary(), dest)
+	(response, address) = sock.recvfrom(1024)
+	print 'respon', response.encode('hex')
+
+	conv = DnsPacketConverter()
+	packet = conv.fromBinary(response)
+	print packet
+