436 lines
16 KiB
Python
436 lines
16 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: UTF-8 -*-
|
|
|
|
"""
|
|
tcp_socket (TCP Socket)
|
|
=======================
|
|
|
|
**Author:**
|
|
|
|
* Dirk Alders <sudo-dirk@mount-mockery.de>
|
|
|
|
**Description:**
|
|
|
|
This Module supports a client/ server tcp socket connection.
|
|
|
|
**Submodules:**
|
|
|
|
* :class:`tcp_socket.tcp_client`
|
|
* :class:`tcp_socket.tcp_client_stp`
|
|
* :class:`tcp_socket.tcp_server`
|
|
* :class:`tcp_socket.tcp_server_stp`
|
|
|
|
**Unittest:**
|
|
|
|
See also the :download:`unittest <../../tcp_socket/_testresults_/unittest.pdf>` documentation.
|
|
"""
|
|
__DEPENDENCIES__ = ['stringtools', 'task', ]
|
|
|
|
import stringtools
|
|
import task
|
|
|
|
import logging
|
|
import socket
|
|
import time
|
|
|
|
logger_name = 'TCP_SOCKET'
|
|
logger = logging.getLogger(logger_name)
|
|
|
|
|
|
class tcp_base(object):
|
|
"""
|
|
:param host: The host IP for the TCP socket functionality
|
|
:type host: str
|
|
:param port: The port for the TCP socket functionality
|
|
:type port: int
|
|
:param rx_log_lvl: The log level to log incomming RX-data
|
|
:type rx_log_lvl: int
|
|
|
|
This is the base class for other classes in this module.
|
|
|
|
.. note:: This class is not designed for direct usage.
|
|
"""
|
|
LOG_PREFIX = 'TCP_IP:'
|
|
RX_LENGTH = 0xff
|
|
COM_TIMEOUT = 0.5
|
|
|
|
def __init__(self, host, port, rx_log_lvl=logging.INFO):
|
|
self.host = host
|
|
self.port = port
|
|
self.__socket__ = None
|
|
self.__data_available_callback__ = None
|
|
self.__supress_data_available_callback__ = False
|
|
self.__connect_callback__ = None
|
|
self.__disconnect_callback__ = None
|
|
self.__clean_receive_buffer__()
|
|
self.__connection__ = None
|
|
self.__listening_message_displayed__ = False
|
|
self.__client_address__ = None
|
|
self.__queue__ = task.threaded_queue()
|
|
self.__queue__.enqueue(5, self.__receive_task__, rx_log_lvl)
|
|
self.__queue__.run()
|
|
|
|
def client_address(self):
|
|
"""
|
|
:return: The client address.
|
|
:rtype: str
|
|
|
|
This method returns the address of the connected client.
|
|
"""
|
|
return self.__client_address__[0]
|
|
|
|
def receive(self, timeout=1, num=None):
|
|
"""
|
|
:param timeout: The timeout for receiving data (at least after the timeout the method returns data or None).
|
|
:type timeout: float
|
|
:param num: the number of bytes to receive (use None to get all available data).
|
|
:type num: int
|
|
:return: The received data.
|
|
:rtype: str
|
|
|
|
This method returns data received via the initiated communication channel.
|
|
"""
|
|
rv = None
|
|
if self.__connection__ is not None:
|
|
tm = time.time()
|
|
while (num is not None and len(self.__receive_buffer__) < num) or (num is None and len(self.__receive_buffer__) < 1):
|
|
if self.__connection__ is None:
|
|
return None
|
|
if time.time() > tm + timeout:
|
|
logger.warning('%s TIMEOUT (%ss): Not enough data in buffer. Requested %s and buffer size is %d.', self.LOG_PREFIX, repr(timeout), repr(num or 'all'), len(self.__receive_buffer__))
|
|
return None
|
|
time.sleep(0.05)
|
|
if num is None:
|
|
rv = self.__receive_buffer__
|
|
self.__clean_receive_buffer__()
|
|
else:
|
|
rv = self.__receive_buffer__[:num]
|
|
self.__receive_buffer__ = self.__receive_buffer__[num:]
|
|
return rv
|
|
|
|
def send(self, data, timeout=1, log_lvl=logging.INFO):
|
|
"""
|
|
:param data: The data to be send over the communication channel.
|
|
:type data: str
|
|
:param timeout: The timeout for sending data (e.g. time to establish new connection).
|
|
:type timeout: float
|
|
:param rx_log_lvl: The log level to log outgoing TX-data
|
|
:type rx_log_lvl: int
|
|
:return: True if data had been sent, otherwise False.
|
|
:rtype: bool
|
|
|
|
This method sends data via the initiated communication channel.
|
|
"""
|
|
cnt = 0
|
|
while self.__connection__ is None and cnt < int(10 * timeout):
|
|
time.sleep(.1) # give some time to establish the connection
|
|
cnt += 1
|
|
if self.__connection__ is not None:
|
|
self.__connection__.sendall(data)
|
|
logger.log(log_lvl, '%s TX -> "%s"', self.LOG_PREFIX, stringtools.hexlify(data))
|
|
return True
|
|
else:
|
|
logger.warning('%s Cound NOT send -> "%s"', self.LOG_PREFIX, stringtools.hexlify(data))
|
|
return False
|
|
|
|
def register_callback(self, callback):
|
|
"""
|
|
:param callback: The callback which will be executed, when data is available.
|
|
:type callback: function
|
|
|
|
This method sets the callback which is executed, if data is available. You need to execute :func:`receive` of the instance
|
|
given with the first argument.
|
|
|
|
.. note:: The :func:`callback` is executed with these arguments:
|
|
|
|
:param self: This communication instance
|
|
"""
|
|
self.__data_available_callback__ = callback
|
|
|
|
def register_connect_callback(self, callback):
|
|
"""
|
|
:param callback: The callback which will be executed, when a connect is identified.
|
|
:type callback: function
|
|
|
|
This method sets the callback which is executed, if a connect is identified.
|
|
"""
|
|
self.__connect_callback__ = callback
|
|
|
|
def register_disconnect_callback(self, callback):
|
|
"""
|
|
:param callback: The callback which will be executed, when a disconnect is identified.
|
|
:type callback: function
|
|
|
|
This method sets the callback which is executed, if a disconnect is identified.
|
|
"""
|
|
self.__disconnect_callback__ = callback
|
|
|
|
def __receive_task__(self, queue_inst, rx_log_lvl):
|
|
if self.__connection__ is not None:
|
|
try:
|
|
data = self.__connection__.recv(self.RX_LENGTH)
|
|
except socket.error as e:
|
|
if e.errno != 11:
|
|
raise
|
|
else:
|
|
time.sleep(.05)
|
|
else:
|
|
if len(data) > 0:
|
|
logger.log(rx_log_lvl, '%s RX <- "%s"', self.LOG_PREFIX, stringtools.hexlify(data))
|
|
self.__receive_buffer__ += data
|
|
else:
|
|
self.__connection_lost__()
|
|
self.__call_data_available_callback__()
|
|
else:
|
|
self.__connect__()
|
|
queue_inst.enqueue(5, self.__receive_task__, rx_log_lvl)
|
|
|
|
def __call_data_available_callback__(self):
|
|
if len(self.__receive_buffer__) > 0 and not self.__supress_data_available_callback__ and self.__data_available_callback__ is not None:
|
|
self.__supress_data_available_callback__ = True
|
|
self.__data_available_callback__(self)
|
|
self.__supress_data_available_callback__ = False
|
|
|
|
def __connection_lost__(self):
|
|
self.__listening_message_displayed__ = False
|
|
self.__connection__.close()
|
|
self.__connection__ = None
|
|
self.__client_address__ = None
|
|
logger.info('%s Connection lost...', self.LOG_PREFIX)
|
|
if self.__disconnect_callback__ is not None:
|
|
self.__disconnect_callback__()
|
|
|
|
def __clean_receive_buffer__(self):
|
|
logger.debug("%s Cleaning up receive-buffer", self.LOG_PREFIX)
|
|
self.__receive_buffer__ = ""
|
|
|
|
def close(self):
|
|
"""
|
|
This method closes the active communication channel, if channel exists.
|
|
"""
|
|
self.__queue__.stop()
|
|
self.__queue__.join()
|
|
if self.__connection__ is not None:
|
|
self.__connection_lost__()
|
|
if self.__socket__ is not None:
|
|
self.__socket__.close()
|
|
|
|
def __del__(self):
|
|
self.close()
|
|
|
|
|
|
class tcp_server(tcp_base):
|
|
"""
|
|
:param host: The host IP for the TCP socket functionality
|
|
:type host: str
|
|
:param port: The port for the TCP socket functionality
|
|
:type port: int
|
|
:param rx_log_lvl: The log level to log incomming RX-data
|
|
:type rx_log_lvl: int
|
|
|
|
This class supports a tcp-server transfering a serial stream of bytes (characters).
|
|
|
|
.. note:: You need a :class:`tcp_client` to communicate with the server.
|
|
|
|
**Example:**
|
|
|
|
.. literalinclude:: ../../tcp_socket/_examples_/tcp_socket__tcp_server.py
|
|
|
|
.. literalinclude:: ../../tcp_socket/_examples_/tcp_socket__tcp_server.log
|
|
"""
|
|
def __connect__(self):
|
|
if self.__socket__ is None:
|
|
# Create a TCP/IP socket
|
|
self.__socket__ = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
# Bind the socket to the port
|
|
server_address = (self.host, self.port)
|
|
self.__socket__.bind(server_address)
|
|
# Listen for incoming connections
|
|
self.__socket__.listen(1)
|
|
self.__socket__.settimeout(self.COM_TIMEOUT)
|
|
self.__socket__.setblocking(False)
|
|
if not self.__listening_message_displayed__:
|
|
logger.info('%s Server listening to %s:%d', self.LOG_PREFIX, self.host, self.port)
|
|
self.__listening_message_displayed__ = True
|
|
try:
|
|
self.__connection__, self.__client_address__ = self.__socket__.accept()
|
|
except socket.error as e:
|
|
if e.errno != 11:
|
|
raise
|
|
else:
|
|
time.sleep(.05)
|
|
else:
|
|
logger.info('%s Connection established... (from %s)', self.LOG_PREFIX, self.client_address())
|
|
self.__clean_receive_buffer__()
|
|
self.__connection__.setblocking(False)
|
|
if self.__connect_callback__ is not None:
|
|
self.__connect_callback__()
|
|
|
|
|
|
class tcp_client(tcp_base):
|
|
"""
|
|
:param host: The host IP for the TCP socket functionality
|
|
:type host: str
|
|
:param port: The port for the TCP socket functionality
|
|
:type port: int
|
|
:param rx_log_lvl: The log level to log incomming RX-data
|
|
:type rx_log_lvl: int
|
|
|
|
This class supports a tcp-client transfering a serial stream of bytes (characters).
|
|
|
|
.. note:: You need a running :class:`tcp_server` listening at the given IP and port to communicate.
|
|
|
|
**Example:**
|
|
|
|
.. literalinclude:: ../../tcp_socket/_examples_/tcp_socket__tcp_client.py
|
|
|
|
.. literalinclude:: ../../tcp_socket/_examples_/tcp_socket__tcp_client.log
|
|
"""
|
|
def __connect__(self):
|
|
if self.__socket__ is None:
|
|
# Create a TCP/IP socket
|
|
self.__socket__ = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
self.__socket__.setblocking(False)
|
|
# Connect the socket to the port where the server is listening
|
|
try:
|
|
self.__socket__.connect((self.host, self.port))
|
|
except socket.error as e:
|
|
if e.errno == 9:
|
|
self.__socket__.close()
|
|
elif e.errno != 115 and e.errno != 111 and e.errno != 114:
|
|
raise
|
|
else:
|
|
self.__connection__ = None
|
|
time.sleep(.05)
|
|
else:
|
|
logger.info('%s Connection to %s:%s established', self.LOG_PREFIX, self.host, self.port)
|
|
self.__clean_receive_buffer__()
|
|
self.__connection__ = self.__socket__
|
|
if self.__connect_callback__ is not None:
|
|
self.__connect_callback__()
|
|
|
|
|
|
class tcp_base_stp(tcp_base):
|
|
"""
|
|
:param host: The host IP for the TCP socket functionality
|
|
:type host: str
|
|
:param port: The port for the TCP socket functionality
|
|
:type port: int
|
|
:param rx_log_lvl: The log level to log incomming RX-data
|
|
:type rx_log_lvl: int
|
|
|
|
This is the base class for other classes in this module.
|
|
|
|
.. note:: This class is not designed for direct usage.
|
|
"""
|
|
|
|
def __init__(self, host, port, rx_log_lvl=logging.INFO):
|
|
tcp_base.__init__(self, host, port, rx_log_lvl=rx_log_lvl)
|
|
self.__stp__ = stringtools.stp.stp()
|
|
|
|
def __clean_receive_buffer__(self):
|
|
logger.debug("%s Cleaning up receive-buffer", self.LOG_PREFIX)
|
|
self.__receive_buffer__ = []
|
|
|
|
def receive(self, timeout=1):
|
|
"""
|
|
:param timeout: The timeout for receiving data (at least after the timeout the method returns data or None).
|
|
:type timeout: float
|
|
:return: The received data.
|
|
:rtype: str
|
|
|
|
This method returns one received messages via the initiated communication channel.
|
|
"""
|
|
try:
|
|
return tcp_base.receive(self, timeout=timeout, num=1)[0]
|
|
except TypeError:
|
|
return None
|
|
|
|
def send(self, data, timeout=1, log_lvl=logging.INFO):
|
|
"""
|
|
:param data: The message to be send over the communication channel.
|
|
:type data: str
|
|
:param timeout: The timeout for sending data (e.g. time to establish new connection).
|
|
:type timeout: float
|
|
:param rx_log_lvl: The log level to log outgoing TX-data
|
|
:type rx_log_lvl: int
|
|
:return: True if data had been sent, otherwise False.
|
|
:rtype: bool
|
|
|
|
This method sends one message via the initiated communication channel.
|
|
"""
|
|
if tcp_base.send(self, stringtools.stp.build_frame(data), timeout=timeout, log_lvl=logging.DEBUG):
|
|
logger.log(log_lvl, '%s TX -> "%s"', self.LOG_PREFIX, stringtools.hexlify(data))
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def __receive_task__(self, queue_inst, rx_log_lvl):
|
|
if self.__connection__ is not None:
|
|
try:
|
|
data = self.__connection__.recv(self.RX_LENGTH)
|
|
except socket.error as e:
|
|
if e.errno == 104:
|
|
self.__connection_lost__()
|
|
elif e.errno != 11:
|
|
raise
|
|
else:
|
|
time.sleep(.05)
|
|
else:
|
|
if len(data) > 0:
|
|
logger.debug('%s -- <- "%s"', self.LOG_PREFIX, stringtools.hexlify(data))
|
|
content = self.__stp__.process(data)
|
|
for msg in content:
|
|
logger.log(rx_log_lvl, '%s RX <- "%s"', self.LOG_PREFIX, stringtools.hexlify(msg))
|
|
self.__receive_buffer__.append(msg)
|
|
else:
|
|
self.__connection_lost__()
|
|
self.__call_data_available_callback__()
|
|
else:
|
|
self.__connect__()
|
|
queue_inst.enqueue(5, self.__receive_task__, rx_log_lvl)
|
|
|
|
|
|
class tcp_server_stp(tcp_server, tcp_base_stp):
|
|
"""
|
|
:param host: The host IP for the TCP socket functionality
|
|
:type host: str
|
|
:param port: The port for the TCP socket functionality
|
|
:type port: int
|
|
:param rx_log_lvl: The log level to log incomming RX-data
|
|
:type rx_log_lvl: int
|
|
|
|
This class supports a tcp-server transfering a string. The string will be packed on send and unpacked on receive.
|
|
See :mod:`stp` for more information on packing and unpacking.
|
|
|
|
.. note:: You need a :class:`tcp_client_stp` to communicate with the server.
|
|
|
|
**Example:**
|
|
|
|
.. literalinclude:: ../../tcp_socket/_examples_/tcp_socket__tcp_server_stp.py
|
|
|
|
.. literalinclude:: ../../tcp_socket/_examples_/tcp_socket__tcp_server_stp.log
|
|
"""
|
|
pass
|
|
|
|
|
|
class tcp_client_stp(tcp_client, tcp_base_stp):
|
|
"""
|
|
:param host: The host IP for the TCP socket functionality
|
|
:type host: str
|
|
:param port: The port for the TCP socket functionality
|
|
:type port: int
|
|
|
|
This class supports a tcp-server transfering a string. The string will be packed on send and unpacked on receive.
|
|
See :mod:`stp` for more information on packing and unpacking.
|
|
|
|
.. note:: You need a running :class:`tcp_server_stp` listening at the given IP and port to communicate.
|
|
|
|
**Example:**
|
|
|
|
.. literalinclude:: ../../tcp_socket/_examples_/tcp_socket__tcp_server_stp.py
|
|
|
|
.. literalinclude:: ../../tcp_socket/_examples_/tcp_socket__tcp_server_stp.log
|
|
"""
|
|
pass
|