#!/usr/bin/env python
# Script to access random.org for random numbers
# Written by Ali Polatel
# Released under the Gnu General Public License v2
# XXX close stdout and open it as logfile in case of logfile is specified
# don't forget to remove coloring when writing to logfile ;)
import os
import sys
def checkversion():
	""" Check python version """
	too_old = "This program requires python v2.3 or greater\nYour python version :\n %s" % sys.version
	try:
		version = sys.version_info
		if (version[0] < 2) or (version[1] < 3):
			print too_old
			sys.exit(3)
	except AttributeError: # what if we don't have sys.version_info :P
		print too_old
		sys.exit(3)
checkversion()
import urllib
import urllib2
import optparse
import ConfigParser
import string
import re
import time
from optparse import OptionParser


home = os.environ['HOME']
CONF = {}


def main():
	""" Main function """
	opts = getopt()
	if not opts.verbose: switch(0)
	CONF["color"]=opts.color
	parser(opts.config) # Parse configuration
	if opts.file != "stdout":
		sys.stdout.close()
		cprint('cyan','o	Output redirected to %s ' % opts.file)
		if os.path.exists(opts.file):
			try: 
				cprint('green',' [appending]\n')
				sys.stdout = open(opts.file,"a")
			except:
				cprint('red',"o         Error opening output file : %s\n" % sys.exc_info()[1])
				sys.exit(1)
		else:
			sys.stdout = open(opts.file,"w")
	r = Random()
	if opts.mode=="checkbuf" and not opts.verbose: switch(1)
	while 1: # Loop until buffer is >=20%
		state=r.checkbuf()
		if state: break
		else: 
			switch(1)
			cprint('red',"Buffer level is less than 20%\n")
			cprint('red',"Sleeping for %d minutes before retrying\n" % CONF["wait"])
			cprint('red',"Hit ^C to exit\n")
			switch(0)
			try: time.sleep(CONF["wait"]*60)
			except KeyboardInterrupt: sys.exit(3)
	if   opts.mode == 'randnum':  print r.randnum()
	elif opts.mode == 'randseq':  print r.randseq()
	elif opts.mode == 'randbytes': print r.randbyte()
	sys.stdout.close()
def switch(state):
	""" Open/Close sys.stderr """
	if state:
		sys.stderr.close()
		sys.stderr = open("/dev/stderr","a+")
	else:
		sys.stderr.close()
		sys.stderr = open("/dev/null","a+")
def cprint(color,txt,bold=True):
	""" Colorize string 
	if shell is bash and if --nocolor is not set"""
	colors = {'bold': '\x1b[1m', 
	          'normal':'\x1b[0m',
	          'blue':'\x1b[34m',
	          'green':'\x1b[32m',
	          'red':'\x1b[31m',
	          'cyan':'\x1b[36m'
	         }
	if os.environ['SHELL'] != '/bin/bash' or not CONF["color"]: 
		sys.stdout.write(txt)
		return 0
	else:
		text = ""
		if bold: text += "%(bold)s" % colors
		for key in colors:
			if key == color: text += colors[key]
	text+=txt
	text+= "%(normal)s" % colors
	sys.stderr.write(text)
	return 0
def parser(config):
	""" Helper function to parse configurations """
	# look if ~/.randomrc exists and parse it
	# else write default configuration to ~/.randomrc
	if os.path.exists(config): 
		cprint('cyan',"o	Parsing configuration file %s\n" % config)
		parseconf(config)
	else: 
		switch(1)
		cprint('red',"o		Configuration file not found\n")
		cprint('red',"o		Writing default config to %s\n" % config)
		writeconf(config)
		cprint('red',"o		Adjust it as you want and rerun the script\n")
		sys.exit(2)
def writeconf(config):
	""" Write default configuration file """
#	print "%(bold)s%(red)s[warning]\t%(normal)s%(bold)sConfiguration file ~/.randomrc not found\n" % colors
#	print "%(bold)s\t\tWriting default configuration to ~/.randomrc\n" % colors
#	print "%(bold)s\t\tEdit it to suit your needs\n" % colors
	try:conf = open(config,"w")
	except:
		cprint('red',"o		Error opening config file : %s\n" % sys.exc_info()[1])
		sys.exit(1)
	conf.write(
"""# random.py configuration file\n# Have a look at http://random.org/http.html
[buffer]
wait= 3 # Minutes to wait if random.org buffer is <20%
[randnum]
num=100 # The number of integers wanted. Currently limited to 10,000. Defaults to 100.
min=1 # The lower bound of the interval (inclusive). This is the minimum value of any number returned by the server.
max=100 # The upper bound of the interval (inclusive). 
	# This is the maximum value of any number returned by the server. 
	# Currently restricted to 1,000,000,000 or less. Defaults to 100.
col=5   # The number of columns in which to format the numbers. Defaults to 5.
[randbyte]
nbytes=256 # Number of bytes to request
format=file # avaliable options are file,hex,octal and binary
[randseq]
min=1 # The smallest value in the sequence.
max=100 # The largest value in the sequence.	
""")
	conf.close()
	return 0
def parseconf(conffile):
	""" Parse configuration """
# TODO check for configuration file errors
	config = ConfigParser.ConfigParser()
	config.read(conffile)
	CONF["wait"]            = config.get("buffer","wait")
	CONF["num"]     	= config.get("randnum","num")
	CONF["rnum_min"]     	= config.get("randnum","min")
	CONF["rnum_max"]     	= config.get("randnum","max")
	CONF["col"]     	= config.get("randnum","col")
	CONF["nbytes"] 		= config.get("randbyte","nbytes")
	CONF["format"] 		= config.get("randbyte","format")
	CONF["rseq_min"]	= config.get("randseq","min")
	CONF["rseq_max"] 	= config.get("randseq","max")
	# check for comments like format=file # <-- hey I'm here
	notint=('color','format') # int() all except those
	for key in CONF: 
		try: CONF[key] = re.sub(" ?#.*","",CONF[key])
		except TypeError: pass # CONF["color"] is boolean
		if key not in notint: CONF[key] = int(CONF[key])
	return 0
def getopt():
	""" Get options from command line"""
	name = "random.py"
	usage = "usage: %prog [options]"
	desc = "Get random numbers,sequences,bytes from http://random.org"
	modes = ["checkbuf","randnum","randseq","randbytes"]
	p = OptionParser(usage=usage,version="%prog 0.01",description=desc,prog=name)
	
	p.add_option("-v","--verbose",action="store_true",dest="verbose",default=False,help="be verbose")
	p.add_option("-C","--nocolor",action="store_false",dest="color",default=True,help="suppress coloring of output")
	p.add_option("-c","--config",default="%s/.randomrc" % home,metavar="FILE",dest="config",help="specify configuration file. [default:~/.randomrc]")
	p.add_option("-w","--write",default="stdout",metavar="FILE",dest="file",help="specify output FILE. [default:%default]")
	p.add_option("-m","--mode",default="randnum",dest="mode",help="Specify mode: checkbuf,randnum[default],randseq,randbytes")
	(opts,args) = p.parse_args()
	if opts.mode not in modes: p.error("Invalid mode")
	return opts
class Random:
	""" Main class including requests to scripts """
	def __init__(self):
		""" Initialize the class """
		self.url="http://www.random.org/cgi-bin"
		self.name = "random.py 0.01"
		self.mail = "polatel at gmail dot com" # E-mail to put in User-Agent
		self.headers = { "User-Agent" : "%s (%s)" % (self.name,self.mail) }
	def checkbuf(self):
		""" 
		Check random.org buffer 
		return 1 if buffer level is >20% and 0 otherwise 
		"""
	        cprint('cyan',"o	Checking random.org buffer\n")
	    	url = "%s/checkbuf" % self.url
		req = urllib2.Request(url,None,self.headers)
		handle = urllib2.urlopen(req)
		buf = handle.read()
		self.buffer = int ( buf.replace("%\n","") )
		cprint('cyan',"o	Buffer state : ")
		if self.buffer >= 20:
			cprint('green'," %d%%\n" % self.buffer)
			return 1
		else:
			cprint('red'," %d%%\n" % self.buffer)
			return 0
	def randnum(self):
		"""
		Gets a list of integers from randnum script
		num : The number of integers wanted. Currently limited to 10,000. Defaults to 100.
		min : The lower bound of the interval (inclusive). 
		      This is the minimum value of any number returned by the server. 
		      Currently restricted to -1,000,000,000 or greater. 
		      Defaults to 1.
		max : The upper bound of the interval (inclusive). 
		      This is the maximum value of any number returned by the server. 
		      Currently restricted to 1,000,000,000 or less. 
		      Defaults to 100.
		col : The number of columns in which to format the numbers. Defaults to 5.
		"""
		# XXX get these text messages out!
		txt='o	Requesting %(num)d integers from random.org [min:%(rnum_min)d,max:%(rnum_max)d,columns:%(col)d]\n'% CONF
		cprint('cyan',txt)
		url = "%s/randnum?num=%d&min=%d&max=%d&col=%d" % (self.url,CONF["num"],CONF["rnum_min"],CONF["rnum_max"],CONF["col"])
		req = urllib2.Request(url,None,self.headers)
		handle = urllib2.urlopen(req)
		return handle.read()
	def randbyte(self):
		""" 
		Gets a number of raw bytes from randbyte script 
		nbytes : The number of bytes requested. Currently restricted to 16,384. 
		         Defaults to 256.
		format : f -> the numbers are returned as a binary file of MIME type application/octet-stream.
		         h -> hexadecimal with MIME type text/plain
			 o -> octal with MIME type text/plain
			 b -> binary with MIME type text/plain
		"""
	        txt='o	Requesting %(nbytes)d raw bytes with format %(format)s from random.org\n'% CONF
		cprint('cyan',txt)
		url = "%s/randbyte?nbytes=%d&format=%s" % (self.url,CONF["nbytes"],CONF["format"][0])
		req = urllib2.Request(url,None,self.headers)
		handle = urllib2.urlopen(req)
		return handle.read()
	def randseq(self):
		""" 
		Gets a randomized sequence of numbers from randseq script
		min : The smallest value in the sequence
		max : The largest value in the sequence 
		"""
		txt='o	Requesting a random sequence with intervals %(rseq_min)d:%(rseq_max)d.\n' % CONF
		cprint('cyan',txt)
		url = "%s/randseq?min=%d&max=%d" % (self.url,CONF["rseq_min"],CONF["rseq_max"])
		req = urllib2.Request(url,None,self.headers)
		handle = urllib2.urlopen(req)
		return handle.read()
if __name__ == "__main__":
	main()