|
1 # -*- coding: utf-8 -*- |
|
2 #Copyright (C) 2009 Sandro Knauß <bugs@sandroknauss.de> |
|
3 |
|
4 #This program is free software; you can redistribute it and/or modify it under the terms |
|
5 #of the GNU General Public License as published by the Free Software Foundation; |
|
6 #either version 3 of the License, or any later version. |
|
7 #This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; |
|
8 #without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|
9 #See the GNU General Public License for more details. |
|
10 |
|
11 #You should have received a copy of the GNU General Public License |
|
12 #along with this program; if not, see <http://www.gnu.org/licenses/>. |
|
13 |
|
14 # Server code |
|
15 |
|
16 from xmlrpc import SecureUserDBXMLRPCServer,UserDB |
|
17 import time, os, md5 |
|
18 from user import User, Admin |
|
19 import content |
|
20 import anbieter |
|
21 import ConfigParser |
|
22 |
|
23 class MyUserDB(UserDB): |
|
24 def __init__(self, userlist,jobqueue): |
|
25 UserDB.__init__(self, None,userlist,jobqueue) |
|
26 |
|
27 def createUser(self, user): |
|
28 self.userlist[self.createHash(user)]=user["class"](self.jobqueue) |
|
29 |
|
30 class Job(object): |
|
31 ''' |
|
32 Basic class for all jobs |
|
33 ''' |
|
34 def __init__(self,provider,name): |
|
35 self.provider=provider |
|
36 self.name=name |
|
37 self.status = "init" |
|
38 self.dStatus={"good":[], "failed":[]} |
|
39 |
|
40 def start(self): |
|
41 self.status = "started" |
|
42 |
|
43 def stop(self): |
|
44 self.status = "stopped" |
|
45 |
|
46 def getStatus(self,detailed): |
|
47 if detailed and self.status == "started" or self.status == "sended": |
|
48 return self.status, self.dStatus |
|
49 return self.status, {} |
|
50 |
|
51 def getName(self): |
|
52 return self.name |
|
53 |
|
54 def getProvider(self): |
|
55 return self.provider |
|
56 |
|
57 def addGood(self, good): |
|
58 if type(good) == list: |
|
59 self.dStatus['good']=self.dStatus['good']+good |
|
60 else: |
|
61 self.dStatus['good'].append(good) |
|
62 |
|
63 def addFailed(self, failed): |
|
64 if type(failed) == list: |
|
65 self.dStatus['failed']=self.dStatus['failed']+failed |
|
66 else: |
|
67 self.dStatus['failed'].append(failed) |
|
68 |
|
69 class MessageJob(Job): |
|
70 ''' |
|
71 A specialized class for smsjobs |
|
72 ''' |
|
73 def __init__(self,provider,name, message,recipients): |
|
74 self.message=message |
|
75 self.recipients=recipients |
|
76 Job.__init__(self,provider, name) |
|
77 |
|
78 def stop(self): |
|
79 pass |
|
80 |
|
81 def start(self): |
|
82 Job.start(self) |
|
83 self.provider.setJob(self) |
|
84 self.message.sendto(self.provider, self.recipients) |
|
85 self.status="sended" |
|
86 |
|
87 def getMessage(self): |
|
88 return self.message |
|
89 |
|
90 def getRecipients(self): |
|
91 return self.recipients |
|
92 |
|
93 |
|
94 class MySipgate(anbieter.sipgate): |
|
95 |
|
96 def __init__(self,user="",password="" ): |
|
97 anbieter.sipgate.__init__(self, user, password) |
|
98 |
|
99 def setJob(self, job): |
|
100 self.job=job |
|
101 |
|
102 def updateStatus(self, arranged=None, failed=None): |
|
103 if arranged: |
|
104 self.job.addGood(arranged) |
|
105 |
|
106 if failed: |
|
107 self.job.addFailed(failed) |
|
108 |
|
109 class MySMTP(anbieter.SMTP): |
|
110 |
|
111 def __init__(self,config_filename=None,section="smtp"): |
|
112 anbieter.SMTP.__init__(self,config_filename,section) |
|
113 |
|
114 def setJob(self, job): |
|
115 self.job=job |
|
116 |
|
117 def updateStatus(self, arranged=None, failed=None): |
|
118 if arranged: |
|
119 self.job.addGood(arranged) |
|
120 |
|
121 if failed: |
|
122 self.job.addFailed(failed) |
|
123 |
|
124 |
|
125 class Jobs: |
|
126 ''' |
|
127 Providing an list of jobs; each new job gets a hash id |
|
128 ''' |
|
129 def __init__(self,manager, queue,provider): |
|
130 self.jobs={} |
|
131 self.manager=manager |
|
132 self.queue=queue |
|
133 self.provider=provider |
|
134 |
|
135 |
|
136 def __getitem__(self,key): |
|
137 return self.jobs[key] |
|
138 |
|
139 def __registerJob__(self, job): |
|
140 id = self._createID() |
|
141 self.jobs[id]=job |
|
142 self.queue.put(job) |
|
143 return id |
|
144 |
|
145 def newSMS(self,message,recipients): |
|
146 ''' |
|
147 creates a new SMS |
|
148 ''' |
|
149 job=self.manager.MessageJob(self.provider["sms"],message, content.SMS(message),recipients) |
|
150 return self.__registerJob__(job) |
|
151 |
|
152 def newFAX(self,subject, fax,recipients): |
|
153 ''' |
|
154 creates a new Fax |
|
155 ''' |
|
156 job=self.manager.MessageJob(self.provider["fax"],subject, content.FAX(subject, fax),recipients) |
|
157 return self.__registerJob__(job) |
|
158 |
|
159 def newMail(self,subject, body,recipients): |
|
160 ''' |
|
161 creates a new Mail |
|
162 ''' |
|
163 job=self.manager.MessageJob(self.provider["mail"],subject, content.Mail(subject, body),recipients) |
|
164 return self.__registerJob__(job) |
|
165 |
|
166 def _createID(self): |
|
167 ''' |
|
168 creats a random hash id |
|
169 ''' |
|
170 while True: |
|
171 m = md5.new() |
|
172 m.update(str(time.time())) |
|
173 m.update(os.urandom(10)) |
|
174 if not self.jobs.has_key(m.hexdigest): |
|
175 self.jobs[m.hexdigest()]=None |
|
176 break |
|
177 return m.hexdigest() |
|
178 |
|
179 def start(userlist): |
|
180 from multiprocessing import Queue |
|
181 from multiprocessing.managers import BaseManager |
|
182 |
|
183 class MyManager(BaseManager): |
|
184 pass |
|
185 |
|
186 MyManager.register('MessageJob', MessageJob) |
|
187 manager = MyManager() |
|
188 manager.start() |
|
189 |
|
190 |
|
191 #anbieter erzeugen und konfigurieren |
|
192 |
|
193 sip=MySipgate() |
|
194 sip.read_basic_config("iro.conf") |
|
195 |
|
196 localhost=MySMTP() |
|
197 localhost.read_basic_config("iro.conf") |
|
198 |
|
199 #Benutzerdatenbank erstellen |
|
200 queue = Queue() |
|
201 provider={"sms":sip, "fax":sip, "mail":localhost} |
|
202 jobqueue=Jobs(manager, queue, provider) |
|
203 userdb=MyUserDB(userlist,jobqueue) |
|
204 |
|
205 #working thread erstellen |
|
206 from worker import Worker |
|
207 worker=Worker(queue) |
|
208 worker.start() |
|
209 |
|
210 #Server starten |
|
211 cp = ConfigParser.ConfigParser() |
|
212 cp.read(["iro.conf"]) |
|
213 cert=cp.get('server', 'cert') |
|
214 key=cp.get('server', 'key') |
|
215 server = SecureUserDBXMLRPCServer(addr=("localhost", 8000), |
|
216 userdb=userdb, |
|
217 certificate=cert,privatekey=key) |
|
218 server.relam="xmlrpc" |
|
219 |
|
220 print "Server started..." |
|
221 server.serve_forever() |
|
222 |
|
223 worker.terminate() |
|
224 |
|
225 if __name__ == '__main__': |
|
226 userlist=[{"name":"test","password":"test", "class":User}, |
|
227 {"name":"test2","password":"test2", "class": Admin}] |
|
228 start(userlist) |
|
229 |
|
230 |