1 # Server code

     2 

     3 from xmlrpc import SecureXMLRPCServer,SecureAuthentificateXMLRPCRequestHandler

     4 import md5, time, os

     5 

     6 class Job:

     7     def __init__(self,provider,name):

     8         self.provider=provider

     9         self.name=name

    10         self.status="stopped"

    11 

    12     def start(self):

    13         self.status="started"

    14 

    15     def stop(self):

    16         self.status="stopped"

    17 

    18 class SMSJob(Job):

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

    20         self.message=message

    21         self.recipients=recipients

    22         Job.__init__(self,provider,message)

    23 

    24 class Jobs:

    25     def __init__(self,queue,provider):

    26         self.jobs={}

    27         self.queue=queue

    28         self.provider=provider

    29 

    30     def __getitem__(self,key):

    31         return self.jobs[key]

    32 

    33     def newSMS(self,message,recipients):

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

    35         id = self._createID()

    36         self.jobs[id]=job

    37         #self.queue.put(job)

    38         return id

    39 

    40     def _createID(self):

    41         while True:

    42             m = md5.new()

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

    44             m.update(os.urandom(10))

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

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

    47                 break

    48         return m.hexdigest()

    49 

    50 

    51 class User: 

    52     def __init__(self,jobqueue):

    53         self.jobqueue=jobqueue

    54         self.jobs={}

    55 

    56     def status(self,id=None):

    57         if id==None:

    58             jobs=self.jobs

    59         else:

    60             try:

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

    62             except:

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

    64         ret={}

    65         for key in jobs:

    66             job=jobs[key]

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

    68         return ret

    69 

    70     def stop(self,id):

    71         try:

    72             job=self.jobs[id]

    73         except:

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

    75 

    76         job.stop()

    77 

    78     

    79     def startSMS(self,message,recipients):

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

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

    82         return id

    83 

    84 class UserDB:

    85     def __init__(self,userlist,jobqueue):

    86         self.salt=os.urandom(20)

    87         self.jobqueue=jobqueue

    88         self.userlist={}

    89         for user in userlist:

    90             self.createUser(user)

    91 

    92     def createHash(self,username,password):

    93         m=md5.new()

    94         m.update(self.salt)

    95         m.update(username)

    96         m.update(password)

    97         return m.hexdigest()

    98 

    99     def createUser(self,user):

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

   101 

   102     def __getitem__(self,key):

   103         return self.userlist[key]

   104 

   105     

   106 class SecureAuthentificateXMLRPCRequestHandler2(SecureAuthentificateXMLRPCRequestHandler):

   107 

   108     def testUser(self,username,password):

   109         return self.server.activateUser(username,password)

   110 

   111 class SecureUserDBXMLRPCServer(SecureXMLRPCServer):

   112     def __init__(self, addr, userdb, 

   113                  requestHandler=SecureAuthentificateXMLRPCRequestHandler2,

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

   115                  logRequests=1):

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

   117         self.userdb=userdb

   118 

   119     def activateUser(self,username,password):

   120         try:

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

   122             self.register_instance(user)

   123             return True

   124         except KeyError:

   125             return False

   126         

   127 

   128 

   129 def test():

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

   131     server.register_introspection_functions()

   132     server.register_instance(StringFunctions())

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

   134     server.serve_forever()

   135 

   136 if __name__ == '__main__':

   137     test()

   138 

   139