Mercurial > libervia-backend
view sat_frontends/jp/loops.py @ 3237:b0c57c9a4bd8
plugin XEP-0384: OMEMO trust policy:
OMEMO trust policy can now be specified. For now there are 2 policies:
- `manual`: each new device fingerprint must be explicitly trusted or not before the
device can be used, and the message sent
- `BTBV` (Blind Trust Before Verification): each new device fingerprint is automically
trusted, until user manually trust or not a device, in which case the behaviour becomes
the same as for `manual` for the entity. When using the Trust UI, user can put the
entity back to blind trust if they wish.
A message is send as feedback to user when a new device is/must be trusted, trying to
explain clearly what's happening to the user.
Devices which have been automically trusted are marked, so user can know which ones may
cause security issue.
author | Goffi <goffi@goffi.org> |
---|---|
date | Fri, 27 Mar 2020 10:02:14 +0100 |
parents | 9d0df638c8b4 |
children | be6d91572633 |
line wrap: on
line source
#!/usr/bin/env python3 # jp: a SAT command line tool # Copyright (C) 2009-2020 Jérôme Poisson (goffi@goffi.org) # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import sys import asyncio import logging as log from sat.core.i18n import _ from sat_frontends.jp.constants import Const as C log.basicConfig(level=log.WARNING, format='[%(name)s] %(message)s') USER_INTER_MSG = _("User interruption: good bye") class QuitException(BaseException): """Quitting is requested This is used to stop execution when host.quit() is called """ def getJPLoop(bridge_name): if 'dbus' in bridge_name: import signal import threading from gi.repository import GLib class JPLoop: def run(self, jp, args, namespace): signal.signal(signal.SIGINT, self._on_sigint) self._glib_loop = GLib.MainLoop() threading.Thread(target=self._glib_loop.run).start() loop = asyncio.get_event_loop() loop.run_until_complete(jp.main(args=args, namespace=namespace)) loop.run_forever() def quit(self, exit_code): loop = asyncio.get_event_loop() loop.stop() self._glib_loop.quit() sys.exit(exit_code) def call_later(self, delay, callback, *args): """call a callback repeatedly @param delay(int): delay between calls in s @param callback(callable): method to call if the callback return True, the call will continue else the calls will stop @param *args: args of the callbac """ loop = asyncio.get_event_loop() loop.call_later(delay, callback, *args) def _on_sigint(self, sig_number, stack_frame): """Called on keyboard interruption Print user interruption message, set exit code and stop reactor """ print("\r" + USER_INTER_MSG) self.quit(C.EXIT_USER_CANCELLED) else: import signal from twisted.internet import asyncioreactor asyncioreactor.install() from twisted.internet import reactor, defer class JPLoop: def __init__(self): # exit code must be set when using quit, so if it's not set # something got wrong and we must report it self._exit_code = C.EXIT_INTERNAL_ERROR def run(self, jp, *args): self.jp = jp signal.signal(signal.SIGINT, self._on_sigint) defer.ensureDeferred(self._start(jp, *args)) try: reactor.run(installSignalHandlers=False) except SystemExit as e: self._exit_code = e.code sys.exit(self._exit_code) async def _start(self, jp, *args): fut = asyncio.ensure_future(jp.main(*args)) try: await defer.Deferred.fromFuture(fut) except BaseException: import traceback traceback.print_exc() jp.quit(1) def quit(self, exit_code): self._exit_code = exit_code reactor.stop() def _timeout_cb(self, args, callback, delay): try: ret = callback(*args) # FIXME: temporary hack to avoid traceback when using XMLUI # to be removed once create_task is not used anymore in # xmlui_manager (i.e. once sat_frontends.tools.xmlui fully supports # async syntax) except QuitException: return if ret: reactor.callLater(delay, self._timeout_cb, args, callback, delay) def call_later(self, delay, callback, *args): reactor.callLater(delay, self._timeout_cb, args, callback, delay) def _on_sigint(self, sig_number, stack_frame): """Called on keyboard interruption Print user interruption message, set exit code and stop reactor """ print("\r" + USER_INTER_MSG) self._exit_code = C.EXIT_USER_CANCELLED reactor.callFromThread(reactor.stop) if bridge_name == "embedded": raise NotImplementedError # from sat.core import sat_main # sat = sat_main.SAT() return JPLoop