I have written this TCP server in python that runs on a specific port and listens only to a client connection from a microcontroller.
The job of the TCP server is to continuously listen to the client connection and receive data that the tcp server driver loads into mysql in the same localhost.
The logic of the TCP server: home_iot / tcpserver.py
import socket
import sys
import ast
import core
try:
import fcntl
except ImportError:
fcntl = None
import logging
import json
server_address = ("192.168.1.110", 7138)
_LOG = logging.getLogger(__name__)
if sys.version_info.major == 2:
import SocketServer
TCPServer = SocketServer.TCPServer
StreamRequestHandler = SocketServer.StreamRequestHandler
if sys.version_info.major == 3:
import socketserver
TCPServer = socketserver.TCPServer
StreamRequestHandler = socketserver.StreamRequestHandler
class ParticlePhotonRequestHandler(StreamRequestHandler):
def handle(self):
"""Receives data from client.
"""
msg = self.rfile.readline().strip()
if self.client_address and not msg:
_LOG.error("No Data revieved from Client: {}".format(self.client_address(0)))
return
_LOG.debug("Received data from client, {}".format(msg.decode('utf-8')))
# Send some data to client
self.wfile.write("Hello Client....Got your message".encode())
data = ast.literal_eval(msg.decode('utf-8'))
if data:
_LOG.info("Temperature: %s Humidity: %s", data("temp"), data("humidity"))
else:
_LOG.error("No data recieved from particle photon.")
with core._connect() as conn:
if conn:
_LOG.info("Connected to mysql server")
core.insert_row(data, conn)
conn.close()
class Server(TCPServer):
allow_reuse_address = True
# The constant would be better initialized by a systemd module
SYSTEMD_FIRST_SOCKET_FD = 3
def __init__(self, server_address, handler_cls, bind_and_activate=True):
self.handlers = set()
# Invoke base but omit bind/listen steps (performed by systemd activation!)
try:
TCPServer.__init__(self, server_address, handler_cls, bind_and_activate)
except TypeError:
TCPServer.__init__(self, server_address, handler_cls)
# Override socket
self.socket = socket.fromfd(
self.SYSTEMD_FIRST_SOCKET_FD, self.address_family, self.socket_type)
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def server_close(self):
TCPServer.server_close(self)
for handler in self.handlers.copy():
self.shutdown_request(handler.request)
def main():
"""Starts TCPServer.
"""
logging.basicConfig(level=logging.DEBUG)
# Create a TCP Server instance
server = Server(server_address, ParticlePhotonRequestHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
if __name__ == '__main__':
main()
The SystemdL service unit
$ HOME / .config / systemd / user / photon_uploader.service
(Unit)
Description=TCP Server to recieve data from Particle Photon to upload to MySql.
After=multi-user.target
Wants=network-online.target
After=network.target photon_uploader.socket
Requires=photon_uploader.socket
(Service)
Type=idle
Restart=always
RestartSec=6
EnvironmentFile=/home/rock64/.config/systemd/user/photon_uploader.env
ExecStart=/usr/bin/python3 /usr/local/iot/home_iot/tcpserver.py
StandardOutput=file:/var/log/user/photon_uploder.log
StandardError=file:/var/log/user/photon_uploader_error.log
TimeoutStopSec=5
(Install)
WantedBy=multi-user.target
and the socket file:
(Unit)
Description=Socket for Particle Photon uploader to MySql Service
PartOf=photon_uploader.service
(Socket)
ListenStream=127.0.0.1:7138
(Install)
WantedBy=sockets.target
Python code, if executed independently, works and updates the data of the particle photon microcontroller to the mysql server.
if we start on systemd the service works fine and starts the tcp server, but the data is not loaded on the mysql server . (I don't understand what is happening here).
There is nothing in the log file. Except the old crawl errors.
Any help will be greatly appreciated for the improvement and correction of the code that I missed. This is my first TCP server and first systemd service.
