Mercurial > libervia-backend
comparison sat/plugins/plugin_xep_0096.py @ 2624:56f94936df1e
code style reformatting using black
author | Goffi <goffi@goffi.org> |
---|---|
date | Wed, 27 Jun 2018 20:14:46 +0200 |
parents | 26edcf3a30eb |
children | 378188abe941 |
comparison
equal
deleted
inserted
replaced
2623:49533de4540b | 2624:56f94936df1e |
---|---|
18 # along with this program. If not, see <http://www.gnu.org/licenses/>. | 18 # along with this program. If not, see <http://www.gnu.org/licenses/>. |
19 | 19 |
20 from sat.core.i18n import _, D_ | 20 from sat.core.i18n import _, D_ |
21 from sat.core.constants import Const as C | 21 from sat.core.constants import Const as C |
22 from sat.core.log import getLogger | 22 from sat.core.log import getLogger |
23 | |
23 log = getLogger(__name__) | 24 log = getLogger(__name__) |
24 from sat.core import exceptions | 25 from sat.core import exceptions |
25 from sat.tools import xml_tools | 26 from sat.tools import xml_tools |
26 from sat.tools import stream | 27 from sat.tools import stream |
27 from twisted.words.xish import domish | 28 from twisted.words.xish import domish |
41 C.PI_TYPE: "XEP", | 42 C.PI_TYPE: "XEP", |
42 C.PI_PROTOCOLS: ["XEP-0096"], | 43 C.PI_PROTOCOLS: ["XEP-0096"], |
43 C.PI_DEPENDENCIES: ["XEP-0020", "XEP-0095", "XEP-0065", "XEP-0047", "FILE"], | 44 C.PI_DEPENDENCIES: ["XEP-0020", "XEP-0095", "XEP-0065", "XEP-0047", "FILE"], |
44 C.PI_MAIN: "XEP_0096", | 45 C.PI_MAIN: "XEP_0096", |
45 C.PI_HANDLER: "no", | 46 C.PI_HANDLER: "no", |
46 C.PI_DESCRIPTION: _("""Implementation of SI File Transfer""") | 47 C.PI_DESCRIPTION: _("""Implementation of SI File Transfer"""), |
47 } | 48 } |
48 | 49 |
49 | 50 |
50 class XEP_0096(object): | 51 class XEP_0096(object): |
51 # TODO: call self._f.unregister when unloading order will be managing (i.e. when depenencies will be unloaded at the end) | 52 # TODO: call self._f.unregister when unloading order will be managing (i.e. when depenencies will be unloaded at the end) |
52 | 53 |
53 def __init__(self, host): | 54 def __init__(self, host): |
54 log.info(_("Plugin XEP_0096 initialization")) | 55 log.info(_("Plugin XEP_0096 initialization")) |
55 self.host = host | 56 self.host = host |
56 self.managed_stream_m = [self.host.plugins["XEP-0065"].NAMESPACE, | 57 self.managed_stream_m = [ |
57 self.host.plugins["XEP-0047"].NAMESPACE] # Stream methods managed | 58 self.host.plugins["XEP-0065"].NAMESPACE, |
59 self.host.plugins["XEP-0047"].NAMESPACE, | |
60 ] # Stream methods managed | |
58 self._f = self.host.plugins["FILE"] | 61 self._f = self.host.plugins["FILE"] |
59 self._f.register(NS_SI_FT, self.sendFile, priority=0, method_name=u"Stream Initiation") | 62 self._f.register( |
63 NS_SI_FT, self.sendFile, priority=0, method_name=u"Stream Initiation" | |
64 ) | |
60 self._si = self.host.plugins["XEP-0095"] | 65 self._si = self.host.plugins["XEP-0095"] |
61 self._si.registerSIProfile(SI_PROFILE_NAME, self._transferRequest) | 66 self._si.registerSIProfile(SI_PROFILE_NAME, self._transferRequest) |
62 host.bridge.addMethod("siSendFile", ".plugin", in_sign='sssss', out_sign='s', method=self._sendFile) | 67 host.bridge.addMethod( |
68 "siSendFile", ".plugin", in_sign="sssss", out_sign="s", method=self._sendFile | |
69 ) | |
63 | 70 |
64 def unload(self): | 71 def unload(self): |
65 self._si.unregisterSIProfile(SI_PROFILE_NAME) | 72 self._si.unregisterSIProfile(SI_PROFILE_NAME) |
66 | 73 |
67 def _badRequest(self, client, iq_elt, message=None): | 74 def _badRequest(self, client, iq_elt, message=None): |
70 @param iq_elt(domish.Element): initial <IQ> element of the SI request | 77 @param iq_elt(domish.Element): initial <IQ> element of the SI request |
71 @param message(None, unicode): informational message to display in the logs | 78 @param message(None, unicode): informational message to display in the logs |
72 """ | 79 """ |
73 if message is not None: | 80 if message is not None: |
74 log.warning(message) | 81 log.warning(message) |
75 self._si.sendError(client, iq_elt, 'bad-request') | 82 self._si.sendError(client, iq_elt, "bad-request") |
76 | 83 |
77 def _parseRange(self, parent_elt, file_size): | 84 def _parseRange(self, parent_elt, file_size): |
78 """find and parse <range/> element | 85 """find and parse <range/> element |
79 | 86 |
80 @param parent_elt(domish.Element): direct parent of the <range/> element | 87 @param parent_elt(domish.Element): direct parent of the <range/> element |
82 - True if range is required | 89 - True if range is required |
83 - range_offset | 90 - range_offset |
84 - range_length | 91 - range_length |
85 """ | 92 """ |
86 try: | 93 try: |
87 range_elt = parent_elt.elements(NS_SI_FT, 'range').next() | 94 range_elt = parent_elt.elements(NS_SI_FT, "range").next() |
88 except StopIteration: | 95 except StopIteration: |
89 range_ = False | 96 range_ = False |
90 range_offset = None | 97 range_offset = None |
91 range_length = None | 98 range_length = None |
92 else: | 99 else: |
93 range_ = True | 100 range_ = True |
94 | 101 |
95 try: | 102 try: |
96 range_offset = int(range_elt['offset']) | 103 range_offset = int(range_elt["offset"]) |
97 except KeyError: | 104 except KeyError: |
98 range_offset = 0 | 105 range_offset = 0 |
99 | 106 |
100 try: | 107 try: |
101 range_length = int(range_elt['length']) | 108 range_length = int(range_elt["length"]) |
102 except KeyError: | 109 except KeyError: |
103 range_length = file_size | 110 range_length = file_size |
104 | 111 |
105 if range_offset != 0 or range_length != file_size: | 112 if range_offset != 0 or range_length != file_size: |
106 raise NotImplementedError # FIXME | 113 raise NotImplementedError # FIXME |
107 | 114 |
108 return range_, range_offset, range_length | 115 return range_, range_offset, range_length |
109 | 116 |
110 def _transferRequest(self, client, iq_elt, si_id, si_mime_type, si_elt): | 117 def _transferRequest(self, client, iq_elt, si_id, si_mime_type, si_elt): |
111 """Called when a file transfer is requested | 118 """Called when a file transfer is requested |
114 @param si_id(unicode): Stream Initiation session id | 121 @param si_id(unicode): Stream Initiation session id |
115 @param si_mime_type("unicode"): Mime type of the file (or default "application/octet-stream" if unknown) | 122 @param si_mime_type("unicode"): Mime type of the file (or default "application/octet-stream" if unknown) |
116 @param si_elt(domish.Element): request | 123 @param si_elt(domish.Element): request |
117 """ | 124 """ |
118 log.info(_("XEP-0096 file transfer requested")) | 125 log.info(_("XEP-0096 file transfer requested")) |
119 peer_jid = jid.JID(iq_elt['from']) | 126 peer_jid = jid.JID(iq_elt["from"]) |
120 | 127 |
121 try: | 128 try: |
122 file_elt = si_elt.elements(NS_SI_FT, "file").next() | 129 file_elt = si_elt.elements(NS_SI_FT, "file").next() |
123 except StopIteration: | 130 except StopIteration: |
124 return self._badRequest(client, iq_elt, "No <file/> element found in SI File Transfer request") | 131 return self._badRequest( |
132 client, iq_elt, "No <file/> element found in SI File Transfer request" | |
133 ) | |
125 | 134 |
126 try: | 135 try: |
127 feature_elt = self.host.plugins["XEP-0020"].getFeatureElt(si_elt) | 136 feature_elt = self.host.plugins["XEP-0020"].getFeatureElt(si_elt) |
128 except exceptions.NotFound: | 137 except exceptions.NotFound: |
129 return self._badRequest(client, iq_elt, "No <feature/> element found in SI File Transfer request") | 138 return self._badRequest( |
139 client, iq_elt, "No <feature/> element found in SI File Transfer request" | |
140 ) | |
130 | 141 |
131 try: | 142 try: |
132 filename = file_elt["name"] | 143 filename = file_elt["name"] |
133 file_size = int(file_elt["size"]) | 144 file_size = int(file_elt["size"]) |
134 except (KeyError, ValueError): | 145 except (KeyError, ValueError): |
135 return self._badRequest(client, iq_elt, "Malformed SI File Transfer request") | 146 return self._badRequest(client, iq_elt, "Malformed SI File Transfer request") |
136 | 147 |
137 file_date = file_elt.getAttribute("date") | 148 file_date = file_elt.getAttribute("date") |
138 file_hash = file_elt.getAttribute("hash") | 149 file_hash = file_elt.getAttribute("hash") |
139 | 150 |
140 log.info(u"File proposed: name=[{name}] size={size}".format(name=filename, size=file_size)) | 151 log.info( |
141 | 152 u"File proposed: name=[{name}] size={size}".format( |
142 try: | 153 name=filename, size=file_size |
143 file_desc = unicode(file_elt.elements(NS_SI_FT, 'desc').next()) | 154 ) |
155 ) | |
156 | |
157 try: | |
158 file_desc = unicode(file_elt.elements(NS_SI_FT, "desc").next()) | |
144 except StopIteration: | 159 except StopIteration: |
145 file_desc = '' | 160 file_desc = "" |
146 | 161 |
147 try: | 162 try: |
148 range_, range_offset, range_length = self._parseRange(file_elt, file_size) | 163 range_, range_offset, range_length = self._parseRange(file_elt, file_size) |
149 except ValueError: | 164 except ValueError: |
150 return self._badRequest(client, iq_elt, "Malformed SI File Transfer request") | 165 return self._badRequest(client, iq_elt, "Malformed SI File Transfer request") |
151 | 166 |
152 try: | 167 try: |
153 stream_method = self.host.plugins["XEP-0020"].negotiate(feature_elt, 'stream-method', self.managed_stream_m, namespace=None) | 168 stream_method = self.host.plugins["XEP-0020"].negotiate( |
169 feature_elt, "stream-method", self.managed_stream_m, namespace=None | |
170 ) | |
154 except KeyError: | 171 except KeyError: |
155 return self._badRequest(client, iq_elt, "No stream method found") | 172 return self._badRequest(client, iq_elt, "No stream method found") |
156 | 173 |
157 if stream_method: | 174 if stream_method: |
158 if stream_method == self.host.plugins["XEP-0065"].NAMESPACE: | 175 if stream_method == self.host.plugins["XEP-0065"].NAMESPACE: |
159 plugin = self.host.plugins["XEP-0065"] | 176 plugin = self.host.plugins["XEP-0065"] |
160 elif stream_method == self.host.plugins["XEP-0047"].NAMESPACE: | 177 elif stream_method == self.host.plugins["XEP-0047"].NAMESPACE: |
161 plugin = self.host.plugins["XEP-0047"] | 178 plugin = self.host.plugins["XEP-0047"] |
162 else: | 179 else: |
163 log.error(u"Unknown stream method, this should not happen at this stage, cancelling transfer") | 180 log.error( |
181 u"Unknown stream method, this should not happen at this stage, cancelling transfer" | |
182 ) | |
164 else: | 183 else: |
165 log.warning(u"Can't find a valid stream method") | 184 log.warning(u"Can't find a valid stream method") |
166 self._si.sendError(client, iq_elt, 'not-acceptable') | 185 self._si.sendError(client, iq_elt, "not-acceptable") |
167 return | 186 return |
168 | 187 |
169 #if we are here, the transfer can start, we just need user's agreement | 188 # if we are here, the transfer can start, we just need user's agreement |
170 data = {"name": filename, "peer_jid": peer_jid, "size": file_size, "date": file_date, "hash": file_hash, "desc": file_desc, | 189 data = { |
171 "range": range_, "range_offset": range_offset, "range_length": range_length, | 190 "name": filename, |
172 "si_id": si_id, "progress_id": si_id, "stream_method": stream_method, "stream_plugin": plugin} | 191 "peer_jid": peer_jid, |
192 "size": file_size, | |
193 "date": file_date, | |
194 "hash": file_hash, | |
195 "desc": file_desc, | |
196 "range": range_, | |
197 "range_offset": range_offset, | |
198 "range_length": range_length, | |
199 "si_id": si_id, | |
200 "progress_id": si_id, | |
201 "stream_method": stream_method, | |
202 "stream_plugin": plugin, | |
203 } | |
173 | 204 |
174 d = self._f.getDestDir(client, peer_jid, data, data, stream_object=True) | 205 d = self._f.getDestDir(client, peer_jid, data, data, stream_object=True) |
175 d.addCallback(self.confirmationCb, client, iq_elt, data) | 206 d.addCallback(self.confirmationCb, client, iq_elt, data) |
176 | 207 |
177 def confirmationCb(self, accepted, client, iq_elt, data): | 208 def confirmationCb(self, accepted, client, iq_elt, data): |
181 @param iq_elt(domish.Element): initial SI request | 212 @param iq_elt(domish.Element): initial SI request |
182 @param data(dict): session data | 213 @param data(dict): session data |
183 """ | 214 """ |
184 if not accepted: | 215 if not accepted: |
185 log.info(u"File transfer declined") | 216 log.info(u"File transfer declined") |
186 self._si.sendError(client, iq_elt, 'forbidden') | 217 self._si.sendError(client, iq_elt, "forbidden") |
187 return | 218 return |
188 # data, timeout, stream_method, failed_methods = client._xep_0096_waiting_for_approval[sid] | 219 # data, timeout, stream_method, failed_methods = client._xep_0096_waiting_for_approval[sid] |
189 # can_range = data['can_range'] == "True" | 220 # can_range = data['can_range'] == "True" |
190 # range_offset = 0 | 221 # range_offset = 0 |
191 # if timeout.active(): | 222 # if timeout.active(): |
205 # del client._xep_0096_waiting_for_approval[sid] | 236 # del client._xep_0096_waiting_for_approval[sid] |
206 # return | 237 # return |
207 | 238 |
208 # file_obj = self._getFileObject(dest_path, can_range) | 239 # file_obj = self._getFileObject(dest_path, can_range) |
209 # range_offset = file_obj.tell() | 240 # range_offset = file_obj.tell() |
210 d = data['stream_plugin'].createSession(client, data['stream_object'], data['peer_jid'], data['si_id']) | 241 d = data["stream_plugin"].createSession( |
242 client, data["stream_object"], data["peer_jid"], data["si_id"] | |
243 ) | |
211 d.addCallback(self._transferCb, client, data) | 244 d.addCallback(self._transferCb, client, data) |
212 d.addErrback(self._transferEb, client, data) | 245 d.addErrback(self._transferEb, client, data) |
213 | 246 |
214 #we can send the iq result | 247 # we can send the iq result |
215 feature_elt = self.host.plugins["XEP-0020"].chooseOption({'stream-method': data['stream_method']}, namespace=None) | 248 feature_elt = self.host.plugins["XEP-0020"].chooseOption( |
249 {"stream-method": data["stream_method"]}, namespace=None | |
250 ) | |
216 misc_elts = [] | 251 misc_elts = [] |
217 misc_elts.append(domish.Element((SI_PROFILE, "file"))) | 252 misc_elts.append(domish.Element((SI_PROFILE, "file"))) |
218 # if can_range: | 253 # if can_range: |
219 # range_elt = domish.Element((None, "range")) | 254 # range_elt = domish.Element((None, "range")) |
220 # range_elt['offset'] = str(range_offset) | 255 # range_elt['offset'] = str(range_offset) |
225 def _transferCb(self, dummy, client, data): | 260 def _transferCb(self, dummy, client, data): |
226 """Called by the stream method when transfer successfuly finished | 261 """Called by the stream method when transfer successfuly finished |
227 | 262 |
228 @param data: session data | 263 @param data: session data |
229 """ | 264 """ |
230 #TODO: check hash | 265 # TODO: check hash |
231 data['stream_object'].close() | 266 data["stream_object"].close() |
232 log.info(u'Transfer {si_id} successfuly finished'.format(**data)) | 267 log.info(u"Transfer {si_id} successfuly finished".format(**data)) |
233 | 268 |
234 def _transferEb(self, failure, client, data): | 269 def _transferEb(self, failure, client, data): |
235 """Called when something went wrong with the transfer | 270 """Called when something went wrong with the transfer |
236 | 271 |
237 @param id: stream id | 272 @param id: stream id |
238 @param data: session data | 273 @param data: session data |
239 """ | 274 """ |
240 log.warning(u'Transfer {si_id} failed: {reason}'.format(reason=unicode(failure.value), **data)) | 275 log.warning( |
241 data['stream_object'].close() | 276 u"Transfer {si_id} failed: {reason}".format( |
277 reason=unicode(failure.value), **data | |
278 ) | |
279 ) | |
280 data["stream_object"].close() | |
242 | 281 |
243 def _sendFile(self, peer_jid_s, filepath, name, desc, profile=C.PROF_KEY_NONE): | 282 def _sendFile(self, peer_jid_s, filepath, name, desc, profile=C.PROF_KEY_NONE): |
244 client = self.host.getClient(profile) | 283 client = self.host.getClient(profile) |
245 return self.sendFile(client, jid.JID(peer_jid_s), filepath, name or None, desc or None) | 284 return self.sendFile( |
285 client, jid.JID(peer_jid_s), filepath, name or None, desc or None | |
286 ) | |
246 | 287 |
247 def sendFile(self, client, peer_jid, filepath, name=None, desc=None, extra=None): | 288 def sendFile(self, client, peer_jid, filepath, name=None, desc=None, extra=None): |
248 """Send a file using XEP-0096 | 289 """Send a file using XEP-0096 |
249 | 290 |
250 @param peer_jid(jid.JID): recipient | 291 @param peer_jid(jid.JID): recipient |
253 name must not contain "/" characters | 294 name must not contain "/" characters |
254 @param desc: description of the file | 295 @param desc: description of the file |
255 @param extra: not used here | 296 @param extra: not used here |
256 @return: an unique id to identify the transfer | 297 @return: an unique id to identify the transfer |
257 """ | 298 """ |
258 feature_elt = self.host.plugins["XEP-0020"].proposeFeatures({'stream-method': self.managed_stream_m}, namespace=None) | 299 feature_elt = self.host.plugins["XEP-0020"].proposeFeatures( |
300 {"stream-method": self.managed_stream_m}, namespace=None | |
301 ) | |
259 | 302 |
260 file_transfer_elts = [] | 303 file_transfer_elts = [] |
261 | 304 |
262 statinfo = os.stat(filepath) | 305 statinfo = os.stat(filepath) |
263 file_elt = domish.Element((SI_PROFILE, 'file')) | 306 file_elt = domish.Element((SI_PROFILE, "file")) |
264 file_elt['name'] = name or os.path.basename(filepath) | 307 file_elt["name"] = name or os.path.basename(filepath) |
265 assert '/' not in file_elt['name'] | 308 assert "/" not in file_elt["name"] |
266 size = statinfo.st_size | 309 size = statinfo.st_size |
267 file_elt['size'] = str(size) | 310 file_elt["size"] = str(size) |
268 if desc: | 311 if desc: |
269 file_elt.addElement('desc', content=desc) | 312 file_elt.addElement("desc", content=desc) |
270 file_transfer_elts.append(file_elt) | 313 file_transfer_elts.append(file_elt) |
271 | 314 |
272 file_transfer_elts.append(domish.Element((None, 'range'))) | 315 file_transfer_elts.append(domish.Element((None, "range"))) |
273 | 316 |
274 sid, offer_d = self._si.proposeStream(client, peer_jid, SI_PROFILE, feature_elt, file_transfer_elts) | 317 sid, offer_d = self._si.proposeStream( |
318 client, peer_jid, SI_PROFILE, feature_elt, file_transfer_elts | |
319 ) | |
275 args = [filepath, sid, size, client] | 320 args = [filepath, sid, size, client] |
276 offer_d.addCallbacks(self._fileCb, self._fileEb, args, None, args) | 321 offer_d.addCallbacks(self._fileCb, self._fileEb, args, None, args) |
277 return sid | 322 return sid |
278 | 323 |
279 def _fileCb(self, result_tuple, filepath, sid, size, client): | 324 def _fileCb(self, result_tuple, filepath, sid, size, client): |
283 feature_elt = self.host.plugins["XEP-0020"].getFeatureElt(si_elt) | 328 feature_elt = self.host.plugins["XEP-0020"].getFeatureElt(si_elt) |
284 except exceptions.NotFound: | 329 except exceptions.NotFound: |
285 log.warning(u"No <feature/> element found in result while expected") | 330 log.warning(u"No <feature/> element found in result while expected") |
286 return | 331 return |
287 | 332 |
288 choosed_options = self.host.plugins["XEP-0020"].getChoosedOptions(feature_elt, namespace=None) | 333 choosed_options = self.host.plugins["XEP-0020"].getChoosedOptions( |
334 feature_elt, namespace=None | |
335 ) | |
289 try: | 336 try: |
290 stream_method = choosed_options["stream-method"] | 337 stream_method = choosed_options["stream-method"] |
291 except KeyError: | 338 except KeyError: |
292 log.warning(u"No stream method choosed") | 339 log.warning(u"No stream method choosed") |
293 return | 340 return |
305 plugin = self.host.plugins["XEP-0047"] | 352 plugin = self.host.plugins["XEP-0047"] |
306 else: | 353 else: |
307 log.warning(u"Invalid stream method received") | 354 log.warning(u"Invalid stream method received") |
308 return | 355 return |
309 | 356 |
310 stream_object = stream.FileStreamObject(self.host, | 357 stream_object = stream.FileStreamObject( |
311 client, | 358 self.host, client, filepath, uid=sid, size=size |
312 filepath, | 359 ) |
313 uid=sid, | 360 d = plugin.startStream(client, stream_object, jid.JID(iq_elt["from"]), sid) |
314 size=size, | |
315 ) | |
316 d = plugin.startStream(client, stream_object, jid.JID(iq_elt['from']), sid) | |
317 d.addCallback(self._sendCb, client, sid, stream_object) | 361 d.addCallback(self._sendCb, client, sid, stream_object) |
318 d.addErrback(self._sendEb, client, sid, stream_object) | 362 d.addErrback(self._sendEb, client, sid, stream_object) |
319 | 363 |
320 def _fileEb(self, failure, filepath, sid, size, client): | 364 def _fileEb(self, failure, filepath, sid, size, client): |
321 if failure.check(error.StanzaError): | 365 if failure.check(error.StanzaError): |
322 stanza_err = failure.value | 366 stanza_err = failure.value |
323 if stanza_err.code == '403' and stanza_err.condition == 'forbidden': | 367 if stanza_err.code == "403" and stanza_err.condition == "forbidden": |
324 from_s = stanza_err.stanza['from'] | 368 from_s = stanza_err.stanza["from"] |
325 log.info(u"File transfer refused by {}".format(from_s)) | 369 log.info(u"File transfer refused by {}".format(from_s)) |
326 msg = D_(u"The contact {} has refused your file").format(from_s) | 370 msg = D_(u"The contact {} has refused your file").format(from_s) |
327 title = D_(u"File refused") | 371 title = D_(u"File refused") |
328 xml_tools.quickNote(self.host, client, msg, title, C.XMLUI_DATA_LVL_INFO) | 372 xml_tools.quickNote(self.host, client, msg, title, C.XMLUI_DATA_LVL_INFO) |
329 else: | 373 else: |
330 log.warning(_(u"Error during file transfer")) | 374 log.warning(_(u"Error during file transfer")) |
331 msg = D_(u"Something went wrong during the file transfer session initialisation: {reason}").format(reason=unicode(stanza_err)) | 375 msg = D_( |
376 u"Something went wrong during the file transfer session initialisation: {reason}" | |
377 ).format(reason=unicode(stanza_err)) | |
332 title = D_(u"File transfer error") | 378 title = D_(u"File transfer error") |
333 xml_tools.quickNote(self.host, client, msg, title, C.XMLUI_DATA_LVL_ERROR) | 379 xml_tools.quickNote(self.host, client, msg, title, C.XMLUI_DATA_LVL_ERROR) |
334 elif failure.check(exceptions.DataError): | 380 elif failure.check(exceptions.DataError): |
335 log.warning(u'Invalid stanza received') | 381 log.warning(u"Invalid stanza received") |
336 else: | 382 else: |
337 log.error(u'Error while proposing stream: {}'.format(failure)) | 383 log.error(u"Error while proposing stream: {}".format(failure)) |
338 | 384 |
339 def _sendCb(self, dummy, client, sid, stream_object): | 385 def _sendCb(self, dummy, client, sid, stream_object): |
340 log.info(_(u'transfer {sid} successfuly finished [{profile}]').format( | 386 log.info( |
341 sid=sid, | 387 _(u"transfer {sid} successfuly finished [{profile}]").format( |
342 profile=client.profile)) | 388 sid=sid, profile=client.profile |
389 ) | |
390 ) | |
343 stream_object.close() | 391 stream_object.close() |
344 | 392 |
345 def _sendEb(self, failure, client, sid, stream_object): | 393 def _sendEb(self, failure, client, sid, stream_object): |
346 log.warning(_(u'transfer {sid} failed [{profile}]: {reason}').format( | 394 log.warning( |
347 sid=sid, | 395 _(u"transfer {sid} failed [{profile}]: {reason}").format( |
348 profile=client.profile, | 396 sid=sid, profile=client.profile, reason=unicode(failure.value) |
349 reason=unicode(failure.value), | 397 ) |
350 )) | 398 ) |
351 stream_object.close() | 399 stream_object.close() |