# Server code

from xmlrpc import SecureXMLRPCServer,SecureAuthentificateXMLRPCRequestHandler

import md5, time, os

class Job:

    def __init__(self,provider,name):

        self.provider=provider

        self.name=name

        self.status="stopped"

    def start(self):

        self.status="started"

    def stop(self):

        self.status="stopped"

class SMSJob(Job):

    def __init__(self,provider,message,recipients):

        self.message=message

        self.recipients=recipients

        Job.__init__(self,provider,message)

class Jobs:

    def __init__(self,queue,provider):

        self.jobs={}

        self.queue=queue

        self.provider=provider

    def __getitem__(self,key):

        return self.jobs[key]

    def newSMS(self,message,recipients):

        job=SMSJob(self.provider,message,recipients)

        id = self._createID()

        self.jobs[id]=job

        #self.queue.put(job)

        return id

    def _createID(self):

        while True:

            m = md5.new()

            m.update(str(time.time()))

            m.update(os.urandom(10))

            if not self.jobs.has_key(m.hexdigest):

                self.jobs[m.hexdigest()]=None

                break

        return m.hexdigest()

class User: 

    def __init__(self,jobqueue):

        self.jobqueue=jobqueue

        self.jobs={}

    def status(self,id=None):

        if id==None:

            jobs=self.jobs

        else:

            try:

                jobs={id:self.jobs[id]}

            except:

                raise String("No Job with ID: %i" %(id))

        ret={}

        for key in jobs:

            job=jobs[key]

            ret[key]={"name":job.name,"status":job.status}

        return ret

    def stop(self,id):

        try:

            job=self.jobs[id]

        except:

            raise String("No Job with ID: %i" %(id))

        job.stop()

    def startSMS(self,message,recipients):

        id = self.jobqueue.newSMS(message,recipients)

        self.jobs[id]=self.jobqueue[id]

        return id

class UserDB:

    def __init__(self,userlist,jobqueue):

        self.salt=os.urandom(20)

        self.jobqueue=jobqueue

        self.userlist={}

        for user in userlist:

            self.createUser(user)

    def createHash(self,username,password):

        m=md5.new()

        m.update(self.salt)

        m.update(username)

        m.update(password)

        return m.hexdigest()

    def createUser(self,user):

        self.userlist[self.createHash(user.username,user.password)]=User(self.jobqueue)

    def __getitem__(self,key):

        return self.userlist[key]

class SecureAuthentificateXMLRPCRequestHandler2(SecureAuthentificateXMLRPCRequestHandler):

    def testUser(self,username,password):

        return self.server.activateUser(username,password)

class SecureUserDBXMLRPCServer(SecureXMLRPCServer):

    def __init__(self, addr, userdb, 

                 requestHandler=SecureAuthentificateXMLRPCRequestHandler2,

                 certificate="server.cert", privatekey="server.pem",

                 logRequests=1):

        SecureXMLRPCServer.__init__(self, addr, requestHandler, certificate, privatekey, logRequests)

        self.userdb=userdb

    def activateUser(self,username,password):

        try:

            user = self.userdb[self.userdb.createHash(username,password)]

            self.register_instance(user)

            return True

        except KeyError:

            return False

def test():

    server = SecureXMLRPCServer(("localhost", 8000),requestHandler=SecureAuthentificateXMLRPCRequestHandler,certificate="./certs/test.cert.pem",privatekey="./certs/test.key.pem")

    server.register_introspection_functions()

    server.register_instance(StringFunctions())

    server.register_function(lambda x: x*x, 'square')

    server.serve_forever()

if __name__ == '__main__':

    test()