async def process(self):
"""
Processing incomming messages
"""
try:
logger.debug('[%s] [processor] processor wait', self.name)
message = await self._incomming.get()
if str(message) == 'close':
return
if message.tp == aiohttp.MsgType.text:
logger.debug('[%s] [processor] incomming message: %r',
self.name, message.data)
incomming = BaseMessage(
json.loads(message.data.replace('$type', 'type')))
if incomming.type == 'Response':
asyncio.ensure_future(self._conversations[int(
incomming.id[:-5])].response_handler(incomming))
if incomming.type == 'FatSeqUpdate':
peer = incomming.body.peer
if peer:
if peer.id not in self._conversations:
self._conversations[peer.id] = self._conversation(
self, peer, self._outgoing, **self._params)
asyncio.ensure_future(
self._conversations[peer.id].message_handler(
incomming.body.message))
if 'HookData' in incomming.body.type:
self.webhooks_handler(incomming.body.data)
if message.tp in (aiohttp.MsgType.close, aiohttp.MsgType.error):
logger.error(
'[%s] [processor] websocket error: data: %r, extra: %r',
self.name, message.data, message.extra)
except Exception as e:
logger.error('[%s] [processor] error: %s %s', self.name, type(e),
e)
async def response_handler(self, message):
"""
Process responses from server
"""
self._sent.remove(message.id)
logger.debug('[%s] confirmed (%d): %s', self._owner.name,
len(self._sent), message.id)
def __init__(self, owner, peer, outgoing, **kwargs):
"""
"""
self._owner = owner
self._peer = peer
self._outgoing = outgoing
self._kwargs = kwargs
self._id = 0
self._sent = []
self._initialization(kwargs)
logger.debug('[%s] start conversation: %s', self._owner.name,
self._peer.id)
def safe_import(module_name, class_name):
if type(class_name) is list:
for name in class_name:
safe_import(module_name, name)
return
package = __package__
if not package:
package = __name__
try:
module = importlib.import_module(module_name, package)
globals()[class_name] = getattr(module, class_name)
except ImportError as error:
logger.warning("Can't Import class: '%s.%s', %s",
module_name, class_name, error)
logger.debug("%s", traceback.format_exc())
async def run(self):
"""
After run stopping coroutines and closed soclet and session
"""
await super().run()
self.listener_task.cancel()
self.sender_task.cancel()
if self._ws:
await self._ws.close()
logger.debug('[%s] [transport] websocket closed', self.name)
if self._session:
await self._session.close()
logger.debug('[%s] [transport] aiohttp session closed', self.name)
async def _connection(self):
"""
Make wesocket connection
"""
if self._ws is None:
self._session = aiohttp.ClientSession(loop=self._loop)
try:
self._ws = await self._session.ws_connect(self._url)
logger.debug('[%s] [transport] connect: %s', self.name,
self._url)
except Exception as e:
logger.error('[%s] [transport] connect error: %s %s %s',
self.name, self._url, type(e), e)
if self._ws.closed:
try:
self._ws = await self._session.ws_connect(self._url)
logger.debug('[%s] [transport] reconnect: %s', self.name,
self._url)
except Exception as e:
logger.error('[%s] [transport] reconnect error: %s %s',
self.name, self._url, type(e), e)
async def process(self):
"""
Processing websocket messages
"""
logger.debug('[%s] [transport] wait', self.name)
try:
await self._connection()
self.listener_task = asyncio.ensure_future(self._ws.receive())
self.sender_task = asyncio.ensure_future(self._outgoing.get())
done, pending = await asyncio.wait(
[self.listener_task, self.sender_task],
return_when=asyncio.FIRST_COMPLETED)
if self.listener_task in done:
logger.debug('[%s] [transport] receiving', self.name)
await self._incomming.put(self.listener_task.result())
else:
self.listener_task.cancel()
if self.sender_task in done:
message = self.sender_task.result()
if str(message) == 'close':
return
self._ws.send_str(message)
logger.debug('[%s] [transport] sending: %r', self.name,
message)
else:
self.sender_task.cancel()
except Exception as e:
logger.error('[%s] [transport] error: %s %s', self.name, type(e),
e)
def webhooks_handler(self, data64):
""" Processing webhook data """
data = BaseMessage(
json.loads(base64.b64decode(data64['data']).decode()))
logger.debug('[%s] [processor] webhook message: %r', self.name,
data.data)
