import SocketServer
from struct import unpack
import md5
import socket
import time

import log
import passwords
import rrdutils

# Protocol:
# Max 65535 byte payload
# 2 bytes: L - length after md5sum (unsigned short)
# 1 byte: K - Key number (unsigned char)
# 16 bytes: M - MD5Sum of the data + key
# Rest may be repeated for multiple sensors
# 1 byte: N - Length of name (unsigned char)
# N bytes: Name of sensor
# 1 byte: Q - Length of quantity (unsigned char)
# Q bytes: Quantity in rrd database
# 8 bytes: 64 bit timestamp, LSB first (unsigned long long)
# 4 bytes: 32 bit interval in seconds, LSB first (signed integer)
# 1 byte: S - Number of samples (unsigned char)
# S * 4 bytes: Float value (single)

class RequestHandler(SocketServer.BaseRequestHandler):
    def recvwto(self, count):
        '''Receive exactly count bytes or raise exception on timeout'''
        t = time.time() + self.request.gettimeout()
        data = ""
        while len(data) < count:
            data += self.request.recv(count - len(data))
            
            if t < time.time():
                raise socket.timeout
        
        return data
        
    def _handle(self):
        '''Handle request but do not handle exceptions'''
        
        header = self.recvwto(19)
        length, keynum, md5sum = unpack("<HB16s", header)
        
        data = self.recvwto(length)
        
        if md5.new(data + passwords.keys[keynum]).digest() != md5sum:
            log.log("Connection from %s sent wrong digest for key %d, data %s"
                % (str(self.client_address), keynum, repr(data[:64])), log.pri_high)
            return
        
        while data:
            nlen, = unpack("<B", data[0]) # Get length
            name = data[1:(1+nlen)] # Get name
            data = data[(1+nlen):] # Remove from data buffer
            
            qlen, = unpack("<B", data[0])
            quantity = data[1:(1+qlen)]
            data = data[(1+qlen):]
            
            time, = unpack("<Q", data[:8])
            data = data[8:]
            
            interval, = unpack("<I", data[:4])
            data = data[4:]
            
            slen, = unpack("<B", data[0]) # Get number of samples
            data = data[1:]
            samples = []
            
            for i in range(slen):
                value, = unpack("<f", data[:4])
                samples.append((time, value))
                data = data[4:]
                time += interval
            
            try:
                rrdutils.update(name, quantity, samples)
            except KeyboardInterrupt:
                raise
            except:
                log.logexception("Error while updating data from %s:" % str(self.client_address), log.pri_high)
                return
            
            try:
                self.request.send("OK\r\n")
            except:
                pass # Sometimes client closes connection fast
    
    def handle(self):
        self.request.settimeout(30.)
        
        try:
            try:
                self._handle()
            except KeyboardInterrupt:
                raise
            except socket.timeout:
                log.log("Connection from %s timed out" % str(self.client_address), log.pri_low)
            except:
                log.logexception("Error while processing connection from %s:" % str(self.client_address), log.pri_normal)
        finally:
            self.request.close()