168 lines
4.0 KiB
Python
168 lines
4.0 KiB
Python
# Nemubot is a smart and modulable IM bot.
|
|
# Copyright (C) 2012-2016 Mercier Pierre-Olivier
|
|
#
|
|
# 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 logging
|
|
import queue
|
|
import traceback
|
|
|
|
from nemubot.bot import sync_act
|
|
|
|
|
|
class AbstractServer:
|
|
|
|
"""An abstract server: handle communication with an IM server"""
|
|
|
|
def __init__(self, name, fdClass, **kwargs):
|
|
"""Initialize an abstract server
|
|
|
|
Keyword argument:
|
|
name -- Identifier of the socket, for convinience
|
|
fdClass -- Class to instantiate as support file
|
|
"""
|
|
|
|
self._name = name
|
|
self._fd = fdClass(**kwargs)
|
|
|
|
self._logger = logging.getLogger("nemubot.server." + str(self.name))
|
|
self._readbuffer = b''
|
|
self._sending_queue = queue.Queue()
|
|
|
|
|
|
@property
|
|
def name(self):
|
|
if self._name is not None:
|
|
return self._name
|
|
else:
|
|
return self._fd.fileno()
|
|
|
|
|
|
# Open/close
|
|
|
|
def connect(self, *args, **kwargs):
|
|
"""Register the server in _poll"""
|
|
|
|
self._logger.info("Opening connection")
|
|
|
|
self._fd.connect(*args, **kwargs)
|
|
|
|
self._on_connect()
|
|
|
|
def _on_connect(self):
|
|
sync_act("sckt", "register", self._fd.fileno())
|
|
|
|
|
|
def close(self, *args, **kwargs):
|
|
"""Unregister the server from _poll"""
|
|
|
|
self._logger.info("Closing connection")
|
|
|
|
if self._fd.fileno() > 0:
|
|
sync_act("sckt", "unregister", self._fd.fileno())
|
|
|
|
self._fd.close(*args, **kwargs)
|
|
|
|
|
|
# Writes
|
|
|
|
def write(self, message):
|
|
"""Asynchronymously send a message to the server using send_callback
|
|
|
|
Argument:
|
|
message -- message to send
|
|
"""
|
|
|
|
self._sending_queue.put(self.format(message))
|
|
self._logger.debug("Message '%s' appended to write queue coming from %s:%d in %s", message, *traceback.extract_stack(limit=3)[0][:3])
|
|
sync_act("sckt", "write", self._fd.fileno())
|
|
|
|
|
|
def async_write(self):
|
|
"""Internal function used when the file descriptor is writable"""
|
|
|
|
try:
|
|
sync_act("sckt", "unwrite", self._fd.fileno())
|
|
while not self._sending_queue.empty():
|
|
self._write(self._sending_queue.get_nowait())
|
|
self._sending_queue.task_done()
|
|
|
|
except queue.Empty:
|
|
pass
|
|
|
|
|
|
def send_response(self, response):
|
|
"""Send a formated Message class
|
|
|
|
Argument:
|
|
response -- message to send
|
|
"""
|
|
|
|
if response is None:
|
|
return
|
|
|
|
elif isinstance(response, list):
|
|
for r in response:
|
|
self.send_response(r)
|
|
|
|
else:
|
|
vprnt = self.printer()
|
|
response.accept(vprnt)
|
|
self.write(vprnt.pp)
|
|
|
|
|
|
# Read
|
|
|
|
def async_read(self):
|
|
"""Internal function used when the file descriptor is readable
|
|
|
|
Returns:
|
|
A list of fully received messages
|
|
"""
|
|
|
|
ret, self._readbuffer = self.lex(self._readbuffer + self.read())
|
|
|
|
for r in ret:
|
|
yield r
|
|
|
|
|
|
def lex(self, buf):
|
|
"""Assume lexing in default case is per line
|
|
|
|
Argument:
|
|
buf -- buffer to lex
|
|
"""
|
|
|
|
msgs = buf.split(b'\r\n')
|
|
partial = msgs.pop()
|
|
|
|
return msgs, partial
|
|
|
|
|
|
def parse(self, msg):
|
|
raise NotImplemented
|
|
|
|
|
|
# Exceptions
|
|
|
|
def exception(self, flags):
|
|
"""Exception occurs on fd"""
|
|
|
|
self._fd.close()
|
|
|
|
# Proxy
|
|
|
|
def fileno(self):
|
|
return self._fd.fileno()
|