Crash_Override/FreeDATA
1
0
Fork 0
mirror of https://github.com/DJ2LS/FreeDATA synced 2024-05-14 08:04:33 +00:00
Code Issues Projects Releases Packages Wiki Activity
FreeDATA/tnc/sock.py

428 lines
17 KiB
Python
Raw Normal View History

code cleanup
2021-02-16 13:23:57 +00:00
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Dec 25 21:25:14 2020
@author: DJ2LS
better error handling
2021-08-08 09:08:34 +00:00
# GET COMMANDS
# "command" : "..."
# SET COMMANDS
# "command" : "..."
# "parameter" : " ..."
# DATA COMMANDS
# "command" : "..."
# "type" : "..."
# "dxcallsign" : "..."
# "data" : "..."
code cleanup
2021-02-16 13:23:57 +00:00
"""
import socketserver
import threading
moved to ujson
2021-08-23 16:14:00 +00:00
import ujson as json
byte rate messurement
2021-03-17 10:22:06 +00:00
import time
code cleanup
2021-02-16 13:23:57 +00:00
import static
renamed arq module to data_handler
2021-02-24 13:22:28 +00:00
import data_handler
new commands
2021-02-16 19:49:02 +00:00
import helpers
better pep8 conformity
2021-09-25 13:24:25 +00:00
import sys
import os
new logging still not finished....
2021-11-18 18:40:22 +00:00
import logging, structlog, log_handler
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
import queue
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
import psutil
import audio
new logging still not finished....
2021-11-18 18:40:22 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
SOCKET_QUEUE = queue.Queue()
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
DAEMON_QUEUE = queue.Queue()
minor modem change problems can occur. changed modem to simultaneous decoding. socket now multithreaded. huge code cleanup neccesary
2021-09-23 15:49:45 +00:00
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
CONNECTED_CLIENTS = set()
better pep8 conformity
2021-09-25 13:24:25 +00:00
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
def send_to_client(self):
while self.connection_alive:
# send tnc state as network stream
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
# check server port against daemon port and send corresponding data
if self.server.server_address[1] == static.PORT and not static.TNCSTARTED:
data = send_tnc_state()
SOCKET_QUEUE.put(data)
else:
data = send_daemon_state()
SOCKET_QUEUE.put(data)
time.sleep(0.5)
while not SOCKET_QUEUE.empty():
data = SOCKET_QUEUE.get()
sock_data = bytes(data, 'utf-8')
sock_data += b'\n' # append line limiter
# send data to all clients
for client in CONNECTED_CLIENTS:
increased CRC increased crc for callsigns to CRC16 and for data to CRC32
2022-01-24 18:42:59 +00:00
try:
client.send(sock_data)
except:
print("connection lost...")
CONNECTED_CLIENTS.remove(self.request)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# we want to transmit scatter data only once to reduce network traffic
static.SCATTER = []
# we want to display INFO messages only once
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
static.INFO = []
#self.request.sendall(sock_data)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
time.sleep(0.15)
def receive_from_client(self):
data = bytes()
while self.connection_alive:
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
# BrokenPipeError: [Errno 32] Broken pipe
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
chunk = self.request.recv(2)
data += chunk
support for different ways controlling the radio #121 direct, rigctl (for windows), rigctld. Highly experimental. Just to save data.
2022-01-18 18:38:05 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
if chunk == b'':
mod out locking state an attempt with a locking state for the mod_out queue so we can process audio only, if we finished filling our mod_out queue. Possibly this solves the problems #99 #127
2022-01-23 06:10:04 +00:00
#print("connection broken. Closing...")
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
self.connection_alive = False
if data.startswith(b'{"type"') and data.endswith(b'}\n'):
data = data[:-1] # remove b'\n'
hotfix for rigctld fixing wrong ip and improved error handling so rigctld is hopefully not crashing for the early testers out there
2022-01-24 21:01:01 +00:00
print(data)
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
if self.server.server_address[1] == static.PORT:
process_tnc_commands(data)
else:
process_daemon_commands(data)
small network improvements tests with fifo queue where not that successfull. This is a part we need to look later on closes #107 and closes #105
2022-01-06 21:15:14 +00:00
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
data = bytes()
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
def handle(self):
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
CONNECTED_CLIENTS.add(self.request)
small network improvements tests with fifo queue where not that successfull. This is a part we need to look later on closes #107 and closes #105
2022-01-06 21:15:14 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
structlog.get_logger("structlog").debug("[TNC] Client connected", ip=self.client_address[0], port=self.client_address[1])
self.connection_alive = True
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
self.sendThread = threading.Thread(target=self.send_to_client, args=[]).start()
self.receiveThread = threading.Thread(target=self.receive_from_client, args=[]).start()
# keep connection alive until we close it
while self.connection_alive:
time.sleep(1)
small network improvements tests with fifo queue where not that successfull. This is a part we need to look later on closes #107 and closes #105
2022-01-06 21:15:14 +00:00
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
better error handling
2021-05-29 14:57:31 +00:00
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
def finish(self):
structlog.get_logger("structlog").warning("[TNC] Closing client socket", ip=self.client_address[0], port=self.client_address[1])
CONNECTED_CLIENTS.remove(self.request)
print(CONNECTED_CLIENTS)
better error handling
2021-05-29 14:57:31 +00:00
arq class and fifo queue processing moved to a much more clear app design. Huge change, so problems and bugs are no surprise.
2022-01-07 10:25:28 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
def process_tnc_commands(data):
# we need to do some error handling in case of socket timeout or decoding issue
try:
arq class and fifo queue processing moved to a much more clear app design. Huge change, so problems and bugs are no surprise.
2022-01-07 10:25:28 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# convert data to json object
received_json = json.loads(data)
# CQ CQ CQ -----------------------------------------------------
if received_json["command"] == "CQCQCQ":
data_handler.DATA_QUEUE_TRANSMIT.put(['CQ'])
small network improvements tests with fifo queue where not that successfull. This is a part we need to look later on closes #107 and closes #105
2022-01-06 21:15:14 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# START_BEACON -----------------------------------------------------
if received_json["command"] == "START_BEACON":
better error handling
2021-05-29 14:57:31 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
static.BEACON_STATE = True
interval = int(received_json["parameter"])
data_handler.DATA_QUEUE_TRANSMIT.put(['BEACON', interval, True])
cleanup, stopping transmission, modem timing... I changed some parts which are R&D as well
2022-01-04 10:55:55 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# STOP_BEACON -----------------------------------------------------
if received_json["command"] == "STOP_BEACON":
static.BEACON_STATE = False
structlog.get_logger("structlog").warning("[TNC] Stopping beacon!")
hotfix for rigctld fixing wrong ip and improved error handling so rigctld is hopefully not crashing for the early testers out there
2022-01-24 21:01:01 +00:00
data_handler.DATA_QUEUE_TRANSMIT.put(['BEACON', None, False])
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# PING ----------------------------------------------------------
if received_json["type"] == 'PING' and received_json["command"] == "PING":
# send ping frame and wait for ACK
dxcallsign = received_json["dxcallsign"]
data_handler.DATA_QUEUE_TRANSMIT.put(['PING', dxcallsign])
# TRANSMIT FILE ----------------------------------------------------------
if received_json["type"] == 'ARQ' and received_json["command"] == "sendFile":
static.TNC_STATE = 'BUSY'
# on a new transmission we reset the timer
static.ARQ_START_OF_TRANSMISSION = int(time.time())
dxcallsign = received_json["dxcallsign"]
mode = int(received_json["mode"])
n_frames = int(received_json["n_frames"])
filename = received_json["filename"]
filetype = received_json["filetype"]
data = received_json["data"]
checksum = received_json["checksum"]
static.DXCALLSIGN = bytes(dxcallsign, 'utf-8')
increased CRC increased crc for callsigns to CRC16 and for data to CRC32
2022-01-24 18:42:59 +00:00
static.DXCALLSIGN_CRC = helpers.get_crc_16(static.DXCALLSIGN)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# dt = datatype
# --> f = file
# --> m = message
# fn = filename
# ft = filetype
# d = data
# crc = checksum
rawdata = {"dt": "f", "fn": filename, "ft": filetype,"d": data, "crc": checksum}
dataframe = json.dumps(rawdata)
data_out = bytes(dataframe, 'utf-8')
rigctld port fix and stuck in re opening data channel data channel stuck in opening process when opening datachannel failed
2022-01-24 22:29:34 +00:00
print("kommen wir hier an?!?")
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
data_handler.DATA_QUEUE_TRANSMIT.put(['ARQ_FILE', data_out, mode, n_frames])
rigctld port fix and stuck in re opening data channel data channel stuck in opening process when opening datachannel failed
2022-01-24 22:29:34 +00:00
print(data_handler.DATA_QUEUE_TRANSMIT.qsize())
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# TRANSMIT MESSAGE ----------------------------------------------------------
if received_json["type"] == 'ARQ' and received_json["command"] == "sendMessage":
static.TNC_STATE = 'BUSY'
print(received_json)
# on a new transmission we reset the timer
static.ARQ_START_OF_TRANSMISSION = int(time.time())
dxcallsign = received_json["dxcallsign"]
mode = int(received_json["mode"])
n_frames = int(received_json["n_frames"])
data = received_json["data"] # d = data
checksum = received_json["checksum"] # crc = checksum
static.DXCALLSIGN = bytes(dxcallsign, 'utf-8')
increased CRC increased crc for callsigns to CRC16 and for data to CRC32
2022-01-24 18:42:59 +00:00
static.DXCALLSIGN_CRC = helpers.get_crc_16(static.DXCALLSIGN)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# dt = datatype
# --> f = file
# --> m = message
# fn = filename
# ft = filetype
# d = data
# crc = checksum
rawdata = {"dt": "m","d": data, "crc": checksum}
dataframe = json.dumps(rawdata)
data_out = bytes(dataframe, 'utf-8')
data_handler.DATA_QUEUE_TRANSMIT.put(['ARQ_MESSAGE', data_out, mode, n_frames])
better pep8 conformity
2021-09-25 13:24:25 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# STOP TRANSMISSION ----------------------------------------------------------
if received_json["type"] == 'ARQ' and received_json["command"] == "stopTransmission":
data_handler.DATA_QUEUE_TRANSMIT.put(['STOP'])
structlog.get_logger("structlog").warning("[TNC] Stopping transmission!")
static.TNC_STATE = 'IDLE'
static.ARQ_STATE = False
if received_json["type"] == 'GET' and received_json["command"] == 'RX_BUFFER':
output = {
"COMMAND": "RX_BUFFER",
"DATA-ARRAY": [],
"EOF": "EOF",
}
for i in range(0, len(static.RX_BUFFER)):
better pep8 conformity
2021-09-25 13:24:25 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
rawdata = json.loads(static.RX_BUFFER[i][3])
output["DATA-ARRAY"].append({"DXCALLSIGN": str(static.RX_BUFFER[i][0], 'utf-8'), "DXGRID": str(static.RX_BUFFER[i][1], 'utf-8'), "TIMESTAMP": static.RX_BUFFER[i][2], "RXDATA": [rawdata]})
better pep8 conformity
2021-09-25 13:24:25 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
jsondata = json.dumps(output)
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
#self.request.sendall(bytes(jsondata, encoding))
SOCKET_QUEUE.put(jsondata)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
if received_json["type"] == 'GET' and received_json["command"] == 'RX_MSG_BUFFER':
output = {
"COMMAND": "RX_MSG_BUFFER",
"DATA-ARRAY": [],
"EOF": "EOF",
}
for i in range(0, len(static.RX_MSG_BUFFER)):
reset sock connection on decoding error
2021-09-08 16:23:26 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
rawdata = json.loads(static.RX_MSG_BUFFER[i][3])
output["DATA-ARRAY"].append({"DXCALLSIGN": str(static.RX_MSG_BUFFER[i][0], 'utf-8'), "DXGRID": str(static.RX_MSG_BUFFER[i][1], 'utf-8'), "TIMESTAMP": static.RX_MSG_BUFFER[i][2], "RXDATA": [rawdata]})
code cleanup gute code clean up with much less global variables now. ARQ beahvior has also been cut down. There can be done even more...
2021-09-27 15:33:59 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
jsondata = json.dumps(output)
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
#self.request.sendall(bytes(jsondata, encoding))
SOCKET_QUEUE.put(jsondata)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
if received_json["type"] == 'SET' and received_json["command"] == 'DEL_RX_BUFFER':
static.RX_BUFFER = []
if received_json["type"] == 'SET' and received_json["command"] == 'DEL_RX_MSG_BUFFER':
static.RX_MSG_BUFFER = []
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
# exception, if JSON cant be decoded
except Exception as e:
structlog.get_logger("structlog").error("[TNC] Network error", e=e)
def send_tnc_state():
encoding = 'utf-8'
output = {
"COMMAND": "TNC_STATE",
"PTT_STATE": str(static.PTT_STATE),
"TNC_STATE": str(static.TNC_STATE),
"ARQ_STATE": str(static.ARQ_STATE),
"AUDIO_RMS": str(static.AUDIO_RMS),
"SNR": str(static.SNR),
"FREQUENCY": str(static.HAMLIB_FREQUENCY),
"MODE": str(static.HAMLIB_MODE),
"BANDWITH": str(static.HAMLIB_BANDWITH),
"FFT": str(static.FFT),
"SCATTER": static.SCATTER,
"RX_BUFFER_LENGTH": str(len(static.RX_BUFFER)),
"RX_MSG_BUFFER_LENGTH": str(len(static.RX_MSG_BUFFER)),
"ARQ_BYTES_PER_MINUTE": str(static.ARQ_BYTES_PER_MINUTE),
"ARQ_BYTES_PER_MINUTE_BURST": str(static.ARQ_BYTES_PER_MINUTE_BURST),
"ARQ_COMPRESSION_FACTOR": str(static.ARQ_COMPRESSION_FACTOR),
"ARQ_TRANSMISSION_PERCENT": str(static.ARQ_TRANSMISSION_PERCENT),
"TOTAL_BYTES": str(static.TOTAL_BYTES),
"INFO" : static.INFO,
"BEACON_STATE" : str(static.BEACON_STATE),
"STATIONS": [],
"MY_CALLSIGN": str(static.MYCALLSIGN, encoding),
"DX_CALLSIGN": str(static.DXCALLSIGN, encoding),
"DX_GRID": str(static.DXGRID, encoding),
"EOF": "EOF",
}
# add heard stations to heard stations object
for i in range(0, len(static.HEARD_STATIONS)):
output["STATIONS"].append({"DXCALLSIGN": str(static.HEARD_STATIONS[i][0], 'utf-8'), "DXGRID": str(static.HEARD_STATIONS[i][1], 'utf-8'),"TIMESTAMP": static.HEARD_STATIONS[i][2], "DATATYPE": static.HEARD_STATIONS[i][3], "SNR": static.HEARD_STATIONS[i][4], "OFFSET": static.HEARD_STATIONS[i][5], "FREQUENCY": static.HEARD_STATIONS[i][6]})
jsondata = json.dumps(output)
return jsondata
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
def process_daemon_commands(data):
# convert data to json object
received_json = json.loads(data)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
if received_json["type"] == 'SET' and received_json["command"] == 'MYCALLSIGN':
callsign = received_json["parameter"]
print(received_json)
if bytes(callsign, 'utf-8') == b'':
self.request.sendall(b'INVALID CALLSIGN')
increased CRC increased crc for callsigns to CRC16 and for data to CRC32
2022-01-24 18:42:59 +00:00
structlog.get_logger("structlog").warning("[DMN] SET MYCALL FAILED", call=static.MYCALLSIGN, crc=static.MYCALLSIGN_CRC)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
else:
static.MYCALLSIGN = bytes(callsign, 'utf-8')
increased CRC increased crc for callsigns to CRC16 and for data to CRC32
2022-01-24 18:42:59 +00:00
static.MYCALLSIGN_CRC = helpers.get_crc_16(static.MYCALLSIGN)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
increased CRC increased crc for callsigns to CRC16 and for data to CRC32
2022-01-24 18:42:59 +00:00
structlog.get_logger("structlog").info("[DMN] SET MYCALL", call=static.MYCALLSIGN, crc=static.MYCALLSIGN_CRC)
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
if received_json["type"] == 'SET' and received_json["command"] == 'MYGRID':
mygrid = received_json["parameter"]
if bytes(mygrid, 'utf-8') == b'':
self.request.sendall(b'INVALID GRID')
else:
static.MYGRID = bytes(mygrid, 'utf-8')
structlog.get_logger("structlog").info("[DMN] SET MYGRID", grid=static.MYGRID)
if received_json["type"] == 'SET' and received_json["command"] == 'STARTTNC' and not static.TNCSTARTED:
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
mycall = str(received_json["parameter"][0]["mycall"])
mygrid = str(received_json["parameter"][0]["mygrid"])
rx_audio = str(received_json["parameter"][0]["rx_audio"])
tx_audio = str(received_json["parameter"][0]["tx_audio"])
devicename = str(received_json["parameter"][0]["devicename"])
deviceport = str(received_json["parameter"][0]["deviceport"])
serialspeed = str(received_json["parameter"][0]["serialspeed"])
pttprotocol = str(received_json["parameter"][0]["pttprotocol"])
pttport = str(received_json["parameter"][0]["pttport"])
data_bits = str(received_json["parameter"][0]["data_bits"])
stop_bits = str(received_json["parameter"][0]["stop_bits"])
handshake = str(received_json["parameter"][0]["handshake"])
radiocontrol = str(received_json["parameter"][0]["radiocontrol"])
rigctld_ip = str(received_json["parameter"][0]["rigctld_ip"])
rigctld_port = str(received_json["parameter"][0]["rigctld_port"])
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
DAEMON_QUEUE.put(['STARTTNC', \
mycall, \
mygrid, \
rx_audio, \
tx_audio, \
devicename, \
deviceport, \
serialspeed, \
pttprotocol, \
pttport, \
data_bits, \
stop_bits, \
handshake, \
radiocontrol, \
rigctld_ip, \
rigctld_port \
])
if received_json["type"] == 'GET' and received_json["command"] == 'TEST_HAMLIB':
devicename = str(received_json["parameter"][0]["devicename"])
deviceport = str(received_json["parameter"][0]["deviceport"])
serialspeed = str(received_json["parameter"][0]["serialspeed"])
pttprotocol = str(received_json["parameter"][0]["pttprotocol"])
pttport = str(received_json["parameter"][0]["pttport"])
data_bits = str(received_json["parameter"][0]["data_bits"])
stop_bits = str(received_json["parameter"][0]["stop_bits"])
handshake = str(received_json["parameter"][0]["handshake"])
radiocontrol = str(received_json["parameter"][0]["radiocontrol"])
rigctld_ip = str(received_json["parameter"][0]["rigctld_ip"])
rigctld_port = str(received_json["parameter"][0]["rigctld_port"])
DAEMON_QUEUE.put(['TEST_HAMLIB', \
devicename, \
deviceport, \
serialspeed, \
pttprotocol, \
pttport, \
data_bits, \
stop_bits, \
handshake, \
radiocontrol, \
rigctld_ip, \
rigctld_port \
])
socket non-block design new design for non blocking network socket. Sock is now streaming status information without need for requesting it.
2022-01-20 19:38:56 +00:00
if received_json["type"] == 'SET' and received_json["command"] == 'STOPTNC':
static.TNCPROCESS.kill()
structlog.get_logger("structlog").warning("[DMN] Stopping TNC")
static.TNCSTARTED = False
new daemon non blocking and multi client support also attempt of fixing #129
2022-01-22 19:39:37 +00:00
def send_daemon_state():
python_version = str(sys.version_info[0]) + "." + str(sys.version_info[1])
output = {
'COMMAND': 'DAEMON_STATE',
'DAEMON_STATE': [],
'PYTHON_VERSION': str(python_version),
'HAMLIB_VERSION': static.HAMLIB_VERSION,
'INPUT_DEVICES': static.AUDIO_INPUT_DEVICES,
'OUTPUT_DEVICES': static.AUDIO_OUTPUT_DEVICES,
'SERIAL_DEVICES': static.SERIAL_DEVICES,
'CPU': str(psutil.cpu_percent()),
'RAM': str(psutil.virtual_memory().percent),
'VERSION': '0.1'
}
if static.TNCSTARTED:
output["DAEMON_STATE"].append({"STATUS": "running"})
else:
output["DAEMON_STATE"].append({"STATUS": "stopped"})
jsondata = json.dumps(output)
return jsondata
Reference in a new issue Copy permalink