code style reformatting using black

This commit is contained in:
Goffi 2018-06-27 20:14:46 +02:00
commit 744cb0c503

View file

@ -21,6 +21,7 @@ from sat.core.i18n import _, D_
from sat.core.constants import Const as C
from sat.core import exceptions
from sat.core.log import getLogger
log = getLogger(__name__)
from sat.tools import xml_tools
from sat.tools import stream
@ -35,8 +36,8 @@ from twisted.internet import interfaces
from zope import interface
import errno
NS_STREAM = 'http://salut-a-toi.org/protocol/stream'
SECURITY_LIMIT=30
NS_STREAM = "http://salut-a-toi.org/protocol/stream"
SECURITY_LIMIT = 30
START_PORT = 8888
PLUGIN_INFO = {
@ -47,7 +48,7 @@ PLUGIN_INFO = {
C.PI_DEPENDENCIES: ["XEP-0166"],
C.PI_MAIN: "JingleStream",
C.PI_HANDLER: "no",
C.PI_DESCRIPTION: _("""Jingle Stream plugin""")
C.PI_DESCRIPTION: _("""Jingle Stream plugin"""),
}
CONFIRM = D_(u"{peer} wants to send you a stream, do you accept ?")
@ -55,7 +56,6 @@ CONFIRM_TITLE = D_(u"Stream Request")
class StreamProtocol(protocol.Protocol):
def __init__(self):
self.pause = False
@ -118,7 +118,9 @@ class StreamFactory(protocol.Factory):
def startStream(self, consumer):
if self.consumer is not None:
raise exceptions.InternalError(_(u"stream can't be used with multiple consumers"))
raise exceptions.InternalError(
_(u"stream can't be used with multiple consumers")
)
assert self.deferred is None
self.consumer = consumer
consumer.registerProducer(self, True)
@ -176,9 +178,17 @@ class JingleStream(object):
def __init__(self, host):
log.info(_("Plugin Stream initialization"))
self.host = host
self._j = host.plugins["XEP-0166"] # shortcut to access jingle
self._j = host.plugins["XEP-0166"] # shortcut to access jingle
self._j.registerApplication(NS_STREAM, self)
host.bridge.addMethod("streamOut", ".plugin", in_sign='ss', out_sign='s', method=self._streamOut, async=True)
host.bridge.addMethod(
"streamOut",
".plugin",
in_sign="ss",
out_sign="s",
method=self._streamOut,
async=True,
)
# jingle callbacks
def _streamOut(self, to_jid_s, profile_key):
@ -206,64 +216,75 @@ class JingleStream(object):
else:
factory.port_listening = port_listening
break
self._j.initiate(client,
to_jid,
[{'app_ns': NS_STREAM,
'senders': self._j.ROLE_INITIATOR,
'app_kwargs': {'stream_object': factory},
}])
self._j.initiate(
client,
to_jid,
[
{
"app_ns": NS_STREAM,
"senders": self._j.ROLE_INITIATOR,
"app_kwargs": {"stream_object": factory},
}
],
)
defer.returnValue(unicode(port))
def jingleSessionInit(self, client, session, content_name, stream_object):
content_data = session['contents'][content_name]
application_data = content_data['application_data']
assert 'stream_object' not in application_data
application_data['stream_object'] = stream_object
desc_elt = domish.Element((NS_STREAM, 'description'))
content_data = session["contents"][content_name]
application_data = content_data["application_data"]
assert "stream_object" not in application_data
application_data["stream_object"] = stream_object
desc_elt = domish.Element((NS_STREAM, "description"))
return desc_elt
@defer.inlineCallbacks
def jingleRequestConfirmation(self, client, action, session, content_name, desc_elt):
"""This method request confirmation for a jingle session"""
content_data = session['contents'][content_name]
if content_data['senders'] not in (self._j.ROLE_INITIATOR, self._j.ROLE_RESPONDER):
content_data = session["contents"][content_name]
if content_data["senders"] not in (
self._j.ROLE_INITIATOR,
self._j.ROLE_RESPONDER,
):
log.warning(u"Bad sender, assuming initiator")
content_data['senders'] = self._j.ROLE_INITIATOR
content_data["senders"] = self._j.ROLE_INITIATOR
confirm_data = yield xml_tools.deferDialog(self.host,
_(CONFIRM).format(peer=session['peer_jid'].full()),
confirm_data = yield xml_tools.deferDialog(
self.host,
_(CONFIRM).format(peer=session["peer_jid"].full()),
_(CONFIRM_TITLE),
type_=C.XMLUI_DIALOG_CONFIRM,
action_extra={'meta_from_jid': session['peer_jid'].full(),
'meta_type': "STREAM",
},
action_extra={
"meta_from_jid": session["peer_jid"].full(),
"meta_type": "STREAM",
},
security_limit=SECURITY_LIMIT,
profile=client.profile)
profile=client.profile,
)
if not C.bool(confirm_data['answer']):
if not C.bool(confirm_data["answer"]):
defer.returnValue(False)
try:
port = int(confirm_data['port'])
port = int(confirm_data["port"])
except (ValueError, KeyError):
raise exceptions.DataError(_(u'given port is invalid'))
endpoint = endpoints.TCP4ClientEndpoint(reactor, 'localhost', port)
raise exceptions.DataError(_(u"given port is invalid"))
endpoint = endpoints.TCP4ClientEndpoint(reactor, "localhost", port)
factory = StreamFactory()
yield endpoint.connect(factory)
content_data['stream_object'] = factory
finished_d = content_data['finished_d'] = defer.Deferred()
content_data["stream_object"] = factory
finished_d = content_data["finished_d"] = defer.Deferred()
args = [client, session, content_name, content_data]
finished_d.addCallbacks(self._finishedCb, self._finishedEb, args, None, args)
defer.returnValue(True)
def jingleHandler(self, client, action, session, content_name, desc_elt):
content_data = session['contents'][content_name]
application_data = content_data['application_data']
content_data = session["contents"][content_name]
application_data = content_data["application_data"]
if action in (self._j.A_ACCEPTED_ACK, self._j.A_SESSION_INITIATE):
pass
elif action == self._j.A_SESSION_ACCEPT:
assert not 'stream_object' in content_data
content_data['stream_object'] = application_data['stream_object']
finished_d = content_data['finished_d'] = defer.Deferred()
assert not "stream_object" in content_data
content_data["stream_object"] = application_data["stream_object"]
finished_d = content_data["finished_d"] = defer.Deferred()
args = [client, session, content_name, content_data]
finished_d.addCallbacks(self._finishedCb, self._finishedEb, args, None, args)
else:
@ -273,9 +294,11 @@ class JingleStream(object):
def _finishedCb(self, dummy, client, session, content_name, content_data):
log.info(u"Pipe transfer completed")
self._j.contentTerminate(client, session, content_name)
content_data['stream_object'].stopStream()
content_data["stream_object"].stopStream()
def _finishedEb(self, failure, client, session, content_name, content_data):
log.warning(u"Error while streaming pipe: {}".format(failure))
self._j.contentTerminate(client, session, content_name, reason=self._j.REASON_FAILED_TRANSPORT)
content_data['stream_object'].stopStream()
self._j.contentTerminate(
client, session, content_name, reason=self._j.REASON_FAILED_TRANSPORT
)
content_data["stream_object"].stopStream()