|
0
|
1 #!/usr/bin/python |
|
|
2 # -*- coding: utf-8 -*- |
|
|
3 |
|
|
4 """ |
|
|
5 SAT: a jabber client |
|
|
6 Copyright (C) 2009 Jérôme Poisson (goffi@goffi.org) |
|
|
7 |
|
|
8 This program is free software: you can redistribute it and/or modify |
|
|
9 it under the terms of the GNU General Public License as published by |
|
|
10 the Free Software Foundation, either version 3 of the License, or |
|
|
11 (at your option) any later version. |
|
|
12 |
|
|
13 This program is distributed in the hope that it will be useful, |
|
|
14 but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
16 GNU General Public License for more details. |
|
|
17 |
|
|
18 You should have received a copy of the GNU General Public License |
|
|
19 along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
20 """ |
|
|
21 |
|
|
22 |
|
|
23 from twisted.internet import glib2reactor, protocol |
|
|
24 glib2reactor.install() |
|
|
25 |
|
|
26 from twisted.words.protocols.jabber import client, jid, xmlstream, error |
|
|
27 from twisted.words.xish import domish |
|
|
28 |
|
|
29 from twisted.internet import reactor |
|
|
30 import pdb |
|
|
31 |
|
|
32 from sat_bridge.DBus import DBusBridge |
|
|
33 import logging |
|
|
34 from logging import debug, info, error |
|
|
35 |
|
|
36 import signal, sys |
|
|
37 import os.path |
|
|
38 |
|
|
39 from tools.memory import Memory |
|
|
40 from glob import glob |
|
|
41 |
|
|
42 |
|
|
43 ### logging configuration FIXME: put this elsewhere ### |
|
|
44 logging.basicConfig(level=logging.DEBUG, |
|
|
45 format='%(message)s') |
|
|
46 ### |
|
|
47 |
|
|
48 |
|
|
49 |
|
|
50 |
|
|
51 class SAT: |
|
|
52 |
|
|
53 def __init__(self): |
|
|
54 self.reactor=reactor |
|
|
55 self.memory=Memory() |
|
|
56 self.server_features=[] #XXX: temp dic, need to be transfered into self.memory in the future |
|
|
57 self.connected=False #FIXME: use twisted var instead |
|
|
58 |
|
|
59 self._iq_cb_map = {} #callback called when ns is found on IQ |
|
|
60 self._waiting_conf = {} #callback called when a confirmation is received |
|
|
61 self._progress_cb_map = {} #callback called when a progress is requested (key = progress id) |
|
|
62 self.plugins = {} |
|
|
63 |
|
|
64 self.bridge=DBusBridge() |
|
|
65 self.bridge.register("connect", self.connect) |
|
1
|
66 self.bridge.register("disconnect", self.disconnect) |
|
0
|
67 self.bridge.register("getContacts", self.memory.getContacts) |
|
|
68 self.bridge.register("getPresenceStatus", self.memory.getPresenceStatus) |
|
|
69 self.bridge.register("sendMessage", self.sendMessage) |
|
|
70 self.bridge.register("setParam", self.setParam) |
|
|
71 self.bridge.register("getParam", self.memory.getParam) |
|
|
72 self.bridge.register("getParams", self.memory.getParams) |
|
|
73 self.bridge.register("getParamsCategories", self.memory.getParamsCategories) |
|
|
74 self.bridge.register("getHistory", self.memory.getHistory) |
|
|
75 self.bridge.register("setPresence", self.setPresence) |
|
|
76 self.bridge.register("addContact", self.addContact) |
|
|
77 self.bridge.register("delContact", self.delContact) |
|
|
78 self.bridge.register("isConnected", self.isConnected) |
|
|
79 self.bridge.register("confirmationAnswer", self.confirmationAnswer) |
|
|
80 self.bridge.register("getProgress", self.getProgress) |
|
|
81 |
|
|
82 self._import_plugins() |
|
|
83 self.connect() |
|
|
84 |
|
|
85 |
|
|
86 def _import_plugins(self): |
|
|
87 """Import all plugins found in plugins directory""" |
|
|
88 #TODO: manage dependencies |
|
|
89 plug_lst = [os.path.splitext(plugin)[0] for plugin in map(os.path.basename,glob ("plugins/plugin*.py"))] |
|
|
90 |
|
|
91 for plug in plug_lst: |
|
|
92 plug_path = 'plugins.'+plug |
|
|
93 __import__(plug_path) |
|
|
94 mod = sys.modules[plug_path] |
|
|
95 plug_info = mod.PLUGIN_INFO |
|
|
96 info ("importing plugin: %s", plug_info['name']) |
|
|
97 self.plugins[plug_info['import_name']] = getattr(mod, plug_info['main'])(self) |
|
|
98 |
|
|
99 def connect(self): |
|
1
|
100 print "Connect !" |
|
0
|
101 if (self.connected): |
|
|
102 info("already connected !") |
|
|
103 return |
|
|
104 info("Connecting...") |
|
|
105 self.me = jid.JID(self.memory.getParamV("JabberID", "Connection")) |
|
|
106 self.factory = client.XMPPClientFactory(self.me, self.memory.getParamV("Password", "Connection")) |
|
|
107 self.factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT,self.authd) |
|
|
108 self.factory.addBootstrap(xmlstream.INIT_FAILED_EVENT,self.failed) |
|
|
109 reactor.connectTCP(self.memory.getParamV("Server", "Connection"), 5222, self.factory) |
|
|
110 self.connectionStatus="online" #TODO: check if connection is OK |
|
|
111 self.connected=True #TODO: use startedConnecting and clientConnectionLost of XMPPClientFactory |
|
|
112 |
|
1
|
113 def disconnect(self): |
|
|
114 if (not self.connected): |
|
|
115 info("not connected !") |
|
|
116 return |
|
|
117 info("Disconnecting...") |
|
0
|
118 |
|
|
119 def run(self): |
|
|
120 debug("running app") |
|
|
121 reactor.run() |
|
|
122 |
|
|
123 def stop(self): |
|
|
124 debug("stopping app") |
|
|
125 reactor.stop() |
|
|
126 |
|
|
127 def authd(self,xmlstream): |
|
|
128 self.xmlstream=xmlstream |
|
|
129 roster=client.IQ(xmlstream,'get') |
|
|
130 roster.addElement(('jabber:iq:roster', 'query')) |
|
|
131 roster.addCallback(self.rosterCb) |
|
|
132 roster.send() |
|
|
133 debug("server = %s",self.memory.getParamV("Server", "Connection")) |
|
|
134 |
|
|
135 ###FIXME: tmp disco ### |
|
|
136 self.memory.registerFeature("http://jabber.org/protocol/disco#info") |
|
|
137 self.disco(self.memory.getParamV("Server", "Connection"), self.serverDisco) |
|
|
138 |
|
|
139 |
|
|
140 #we now send our presence status |
|
|
141 self.setPresence(status="Online") |
|
|
142 |
|
|
143 # add a callback for the messages |
|
|
144 xmlstream.addObserver('/message', self.gotMessage) |
|
|
145 xmlstream.addObserver('/presence', self.presenceCb) |
|
|
146 xmlstream.addObserver("/iq[@type='set' or @type='get']", self.iqCb) |
|
|
147 #reactor.callLater(2,self.sendFile,"goffi2@jabber.goffi.int/Psi", "/tmp/fakefile") |
|
|
148 |
|
|
149 def sendMessage(self,to,msg,type='chat'): |
|
|
150 #FIXME: check validity of recipient |
|
|
151 debug("Sending jabber message to %s...", to) |
|
|
152 message = domish.Element(('jabber:client','message')) |
|
|
153 message["to"] = jid.JID(to).full() |
|
|
154 message["from"] = self.me.full() |
|
|
155 message["type"] = type |
|
|
156 message.addElement("body", "jabber:client", msg) |
|
|
157 self.xmlstream.send(message) |
|
|
158 self.memory.addToHistory(self.me, self.me, jid.JID(to), message["type"], unicode(msg)) |
|
|
159 self.bridge.newMessage(message['from'], unicode(msg), to=message['to']) #We send back the message, so all clients are aware of it |
|
|
160 |
|
|
161 def setParam(self, name, value, namespace): |
|
|
162 """set wanted paramater and notice observers""" |
|
|
163 info ("setting param: %s=%s in namespace %s", name, value, namespace) |
|
|
164 self.memory.setParam(name, value, namespace) |
|
|
165 self.bridge.paramUpdate(name, value, namespace) |
|
|
166 |
|
|
167 def setRoster(self, to): |
|
|
168 """Add a contact to roster list""" |
|
|
169 to_jid=jid.JID(to) |
|
|
170 roster=client.IQ(self.xmlstream,'set') |
|
|
171 query=roster.addElement(('jabber:iq:roster', 'query')) |
|
|
172 item=query.addElement("item") |
|
|
173 item.attributes["jid"]=to_jid.userhost() |
|
|
174 roster.send() |
|
|
175 #TODO: check IQ result |
|
|
176 |
|
|
177 def delRoster(self, to): |
|
|
178 """Remove a contact from roster list""" |
|
|
179 to_jid=jid.JID(to) |
|
|
180 roster=client.IQ(self.xmlstream,'set') |
|
|
181 query=roster.addElement(('jabber:iq:roster', 'query')) |
|
|
182 item=query.addElement("item") |
|
|
183 item.attributes["jid"]=to_jid.userhost() |
|
|
184 item.attributes["subscription"]="remove" |
|
|
185 roster.send() |
|
|
186 #TODO: check IQ result |
|
|
187 |
|
|
188 |
|
|
189 def failed(self,xmlstream): |
|
|
190 debug("failed: %s", xmlstream.getErrorMessage()) |
|
|
191 debug("failed: %s", dir(xmlstream)) |
|
|
192 |
|
|
193 def isConnected(self): |
|
|
194 return self.connected |
|
|
195 |
|
|
196 ## jabber methods ## |
|
|
197 |
|
|
198 def disco (self, item, callback, node=None): |
|
|
199 """XEP-0030 Service discovery Feature.""" |
|
|
200 disco=client.IQ(self.xmlstream,'get') |
|
|
201 disco["from"]=self.me.full() |
|
|
202 disco["to"]=item |
|
|
203 disco.addElement(('http://jabber.org/protocol/disco#info', 'query')) |
|
|
204 disco.addCallback(callback) |
|
|
205 disco.send() |
|
|
206 |
|
|
207 |
|
|
208 def setPresence(self, to="", type="", show="", status="", priority=0): |
|
|
209 """Send our presence information""" |
|
|
210 presence = domish.Element(('jabber:client', 'presence')) |
|
|
211 if not type in ["", "unavailable", "subscribed", "subscribe", |
|
|
212 "unsubscribe", "unsubscribed", "prob", "error"]: |
|
|
213 error("Type error !") |
|
|
214 #TODO: throw an error |
|
|
215 return |
|
|
216 |
|
|
217 if to: |
|
|
218 presence.attributes["to"]=to |
|
|
219 if type: |
|
|
220 presence.attributes["type"]=type |
|
|
221 |
|
|
222 for element in ["show", "status", "priority"]: |
|
|
223 if locals()[element]: |
|
|
224 presence.addElement(element).addContent(unicode(locals()[element])) |
|
|
225 |
|
|
226 self.xmlstream.send(presence) |
|
|
227 |
|
|
228 def addContact(self, to): |
|
|
229 """Add a contact in roster list""" |
|
|
230 to_jid=jid.JID(to) |
|
|
231 self.setRoster(to_jid.userhost()) |
|
|
232 self.setPresence(to_jid.userhost(), "subscribe") |
|
|
233 |
|
|
234 def delContact(self, to): |
|
|
235 """Remove contact from roster list""" |
|
|
236 to_jid=jid.JID(to) |
|
|
237 self.delRoster(to_jid.userhost()) |
|
|
238 self.bridge.contactDeleted(to) |
|
|
239 |
|
|
240 def gotMessage(self,message): |
|
|
241 debug (u"got_message from: %s", message["from"]) |
|
|
242 for e in message.elements(): |
|
|
243 if e.name == "body": |
|
|
244 self.bridge.newMessage(message["from"], e.children[0]) |
|
|
245 self.memory.addToHistory(self.me, jid.JID(message["from"]), self.me, "chat", e.children[0]) |
|
|
246 break |
|
|
247 |
|
|
248 ## callbacks ## |
|
|
249 |
|
|
250 def add_IQ_cb(self, ns, cb): |
|
|
251 """Add an IQ callback on namespace ns""" |
|
|
252 debug ("Registered callback for namespace %s", ns) |
|
|
253 self._iq_cb_map[ns]=cb |
|
|
254 |
|
|
255 def iqCb(self, stanza): |
|
|
256 info ("iqCb") |
|
|
257 debug ("="*20) |
|
|
258 debug ("DEBUG:\n") |
|
|
259 debug (stanza.toXml().encode('utf-8')) |
|
|
260 debug ("="*20) |
|
|
261 #FIXME: temporary ugly code |
|
|
262 uri = stanza.firstChildElement().uri |
|
|
263 if self._iq_cb_map.has_key(uri): |
|
|
264 self._iq_cb_map[uri](stanza) |
|
|
265 #TODO: manage errors stanza |
|
|
266 |
|
|
267 def presenceCb(self, elem): |
|
|
268 info ("presence update for [%s]", elem.getAttribute("from")) |
|
|
269 debug("\n\nXML=\n%s\n\n", elem.toXml()) |
|
|
270 presence={} |
|
|
271 presence["jid"]=elem.getAttribute("from") |
|
|
272 presence["type"]=elem.getAttribute("type") or "" |
|
|
273 presence["show"]="" |
|
|
274 presence["status"]="" |
|
|
275 presence["priority"]=0 |
|
|
276 |
|
|
277 for item in elem.elements(): |
|
|
278 if presence.has_key(item.name): |
|
|
279 presence[item.name]=item.children[0] |
|
|
280 |
|
|
281 ### we check if the status is not about subscription ### |
|
|
282 #TODO: check that from jid is one we wants to subscribe (ie: check a recent subscription asking) |
|
|
283 if jid.JID(presence["jid"]).userhost()!=self.me.userhost(): |
|
|
284 if presence["type"]=="subscribed": |
|
|
285 debug ("subscription answer") |
|
|
286 elif presence["type"]=="unsubscribed": |
|
|
287 debug ("unsubscription answer") |
|
|
288 elif presence["type"]=="subscribe": |
|
|
289 #FIXME: auto answer for subscribe request, must be checked ! |
|
|
290 debug ("subscription request") |
|
|
291 self.setPresence(to=presence["jid"], type="subscribed") |
|
|
292 else: |
|
|
293 #We keep presence information only if it is not for subscription |
|
|
294 self.memory.addPresenceStatus(presence["jid"], presence["type"], presence["show"], |
|
|
295 presence["status"], int(presence["priority"])) |
|
|
296 |
|
|
297 #now it's time to notify frontends |
|
|
298 self.bridge.presenceUpdate(presence["jid"], presence["type"], presence["show"], |
|
|
299 presence["status"], int(presence["priority"])) |
|
|
300 |
|
|
301 def rosterCb(self,roster): |
|
|
302 for contact in roster.firstChildElement().elements(): |
|
|
303 info ("new contact in roster list: %s", contact['jid']) |
|
|
304 #and now the groups |
|
|
305 groups=[] |
|
|
306 for group in contact.elements(): |
|
|
307 if group.name!="group": |
|
|
308 error("Unexpected element !") |
|
|
309 break |
|
|
310 groups.append(str(group)) |
|
|
311 self.memory.addContact(contact['jid'], contact.attributes, groups) |
|
|
312 self.bridge.newContact(contact['jid'], contact.attributes, groups) |
|
|
313 |
|
|
314 def serverDisco(self, disco): |
|
|
315 """xep-0030 Discovery Protocol.""" |
|
|
316 for element in disco.firstChildElement().elements(): |
|
|
317 if element.name=="feature": |
|
|
318 debug ("Feature dectetee: %s",element["var"]) |
|
|
319 self.server_features.append(element["var"]) |
|
|
320 elif element.name=="identity": |
|
|
321 debug ("categorie= %s",element["category"]) |
|
|
322 debug ("features= %s",self.server_features) |
|
|
323 |
|
|
324 ## Generic HMI ## |
|
|
325 |
|
|
326 def askConfirmation(self, id, type, data, cb): |
|
|
327 """Add a confirmation callback""" |
|
|
328 if self._waiting_conf.has_key(id): |
|
|
329 error ("Attempt to register two callbacks for the same confirmation") |
|
|
330 else: |
|
|
331 self._waiting_conf[id] = cb |
|
|
332 self.bridge.askConfirmation(type, id, data) |
|
|
333 |
|
|
334 |
|
|
335 def confirmationAnswer(self, id, accepted, data): |
|
|
336 """Called by frontends to answer confirmation requests""" |
|
|
337 debug ("Received confirmation answer for id [%s]: %s", id, "accepted" if accepted else "refused") |
|
|
338 if not self._waiting_conf.has_key(id): |
|
|
339 error ("Received an unknown confirmation") |
|
|
340 else: |
|
|
341 cb = self._waiting_conf[id] |
|
|
342 del self._waiting_conf[id] |
|
|
343 cb(id, accepted, data) |
|
|
344 |
|
|
345 def registerProgressCB(self, id, CB): |
|
|
346 """Register a callback called when progress is requested for id""" |
|
|
347 self._progress_cb_map[id] = CB |
|
|
348 |
|
|
349 def removeProgressCB(self, id): |
|
|
350 """Remove a progress callback""" |
|
|
351 if not self._progress_cb_map.has_key(id): |
|
|
352 error ("Trying to remove an unknow progress callback") |
|
|
353 else: |
|
|
354 del self._progress_cb_map[id] |
|
|
355 |
|
|
356 def getProgress(self, id): |
|
|
357 """Return a dict with progress information |
|
|
358 data['position'] : current possition |
|
|
359 data['size'] : end_position |
|
|
360 """ |
|
|
361 data = {} |
|
|
362 try: |
|
|
363 self._progress_cb_map[id](data) |
|
|
364 except KeyError: |
|
|
365 pass |
|
|
366 #debug("Requested progress for unknown id") |
|
|
367 return data |
|
|
368 |
|
|
369 |
|
|
370 app=SAT() #TODO: tmp, use twisted way instead |
|
|
371 app.run() |
|
|
372 |
|
|
373 app.memory.save() #FIXME: not the best place |
|
|
374 debug("Good Bye") |
