|
2085
|
1 #!/usr/bin/env python2 |
|
|
2 #-*- coding: utf-8 -*- |
|
|
3 |
|
|
4 # SàT: a XMPP client |
|
|
5 # Copyright (C) 2009-2016 Jérôme Poisson (goffi@goffi.org) |
|
|
6 |
|
|
7 # This program is free software: you can redistribute it and/or modify |
|
|
8 # it under the terms of the GNU Affero General Public License as published by |
|
|
9 # the Free Software Foundation, either version 3 of the License, or |
|
|
10 # (at your option) any later version. |
|
|
11 |
|
|
12 # This program is distributed in the hope that it will be useful, |
|
|
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
15 # GNU Affero General Public License for more details. |
|
|
16 |
|
|
17 # You should have received a copy of the GNU Affero General Public License |
|
|
18 # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
19 |
|
|
20 from sat.bridge.bridge_constructor import base_constructor |
|
|
21 |
|
|
22 |
|
|
23 class DbusConstructor(base_constructor.Constructor): |
|
|
24 NAME = "dbus" |
|
|
25 CORE_TEMPLATE = "dbus_core_template.py" |
|
2086
|
26 CORE_DEST = "dbus_bridge.py" |
|
2085
|
27 CORE_FORMATS = { |
|
|
28 'signals': """\ |
|
|
29 @dbus.service.signal(const_INT_PREFIX+const_{category}_SUFFIX, |
|
|
30 signature='{sig_in}') |
|
|
31 def {name}(self, {args}): |
|
|
32 {body}\n""", |
|
|
33 |
|
|
34 'methods': """\ |
|
|
35 @dbus.service.method(const_INT_PREFIX+const_{category}_SUFFIX, |
|
|
36 in_signature='{sig_in}', out_signature='{sig_out}', |
|
|
37 async_callbacks={async_callbacks}) |
|
|
38 def {name}(self, {args}{async_comma}{async_args_def}): |
|
|
39 {debug}return self._callback("{name}", {args_result}{async_comma}{async_args_call})\n""", |
|
|
40 |
|
|
41 'signal_direct_calls': """\ |
|
|
42 def {name}(self, {args}): |
|
|
43 self.dbus_bridge.{name}({args})\n""", |
|
|
44 } |
|
|
45 |
|
|
46 FRONTEND_TEMPLATE = "dbus_frontend_template.py" |
|
|
47 FRONTEND_DEST = CORE_DEST |
|
|
48 FRONTEND_FORMATS = { |
|
|
49 'methods': """\ |
|
|
50 def {name}(self, {args}{async_comma}{async_args}): |
|
|
51 {error_handler}{blocking_call}{debug}return {result}\n""", |
|
|
52 } |
|
|
53 |
|
|
54 def core_completion_signal(self, completion, function, default, arg_doc, async_): |
|
|
55 completion['category'] = completion['category'].upper() |
|
|
56 completion['body'] = "pass" if not self.args.debug else 'log.debug ("{}")'.format(completion['name']) |
|
|
57 |
|
|
58 def core_completion_method(self, completion, function, default, arg_doc, async_): |
|
|
59 completion.update({ |
|
|
60 'debug': "" if not self.args.debug else 'log.debug ("%s")\n%s' % (completion['name'], 8 * ' '), |
|
|
61 'args_result': self.getArguments(function['sig_in'], name=arg_doc, unicode_protect=self.args.unicode), |
|
|
62 'async_comma': ', ' if async_ and function['sig_in'] else '', |
|
|
63 'async_args_def': 'callback=None, errback=None' if async_ else '', |
|
|
64 'async_args_call': 'callback=callback, errback=errback' if async_ else '', |
|
|
65 'async_callbacks': "('callback', 'errback')" if async_ else "None", |
|
|
66 'category': completion['category'].upper(), |
|
|
67 }) |
|
|
68 |
|
|
69 def frontend_completion_method(self, completion, function, default, arg_doc, async_): |
|
|
70 completion.update({ |
|
|
71 # XXX: we can manage blocking call in the same way as async one: if callback is None the call will be blocking |
|
|
72 'debug': "" if not self.args.debug else 'log.debug ("%s")\n%s' % (completion['name'], 8 * ' '), |
|
|
73 'args_result': self.getArguments(function['sig_in'], name=arg_doc), |
|
|
74 'async_args': 'callback=None, errback=None', |
|
|
75 'async_comma': ', ' if function['sig_in'] else '', |
|
|
76 'error_handler': """if callback is None: |
|
|
77 error_handler = None |
|
|
78 else: |
|
|
79 if errback is None: |
|
|
80 errback = log.error |
|
|
81 error_handler = lambda err:errback(dbus_to_bridge_exception(err)) |
|
|
82 """, |
|
|
83 }) |
|
|
84 if async_: |
|
|
85 completion['blocking_call'] = '' |
|
|
86 completion['async_args_result'] = 'timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler' |
|
|
87 else: |
|
|
88 # XXX: To have a blocking call, we must have not reply_handler, so we test if callback exists, and add reply_handler only in this case |
|
|
89 completion['blocking_call'] = """kwargs={} |
|
|
90 if callback is not None: |
|
|
91 kwargs['timeout'] = const_TIMEOUT |
|
|
92 kwargs['reply_handler'] = callback |
|
|
93 kwargs['error_handler'] = error_handler |
|
|
94 """ |
|
|
95 completion['async_args_result'] = '**kwargs' |
|
|
96 result = "self.db_%(category)s_iface.%(name)s(%(args_result)s%(async_comma)s%(async_args_result)s)" % completion |
|
|
97 completion['result'] = ("unicode(%s)" if self.args.unicode and function['sig_out'] == 's' else "%s") % result |
