Websocket und zugehöriger Daemon getötet beim Upgrade von Python 3.7 -> 3.12.10 ⇐ Linux

[Anonymous]

Ich habe vor einigen Jahren ein Foto -Manager -Programm (FOTO Manager) in Python3.7 geschrieben, das WebSocket -Anrufe zwischen einem Python -Daemon und einem JavaScript -HTML -Seiten in Firefox verwendet. Mit Python 3.7 funktionierte die Dinge in Ordnung - aber jetzt auf einem neuen Computer, der Slackware V15+ aktuell ausführt, schlägt mein Skript vollständig mit Python 3.12 und der zugehörigen neuen WebSocket -Bibliothek aus. Ich habe die neuesten WebSocket -Anweisungen zu den erforderlichen Syntax -Änderungen gelesen, aber ich kann meinen Code immer noch nicht wieder ausführen lassen. Meines Wissens hört der Code immer an derselben Stelle an, dh "-Code und Protokolle Halt hier !!! ---" (siehe unten) oder zumindest hier sehe ich die letzten Protokolle, die in einer externen Protokolldatei enden. Sobald der Code die Dämon -Phase erreicht hat, werden die Dinge, die dort stattfinden, auf dem Terminal unsichtbar, sollte aber in dieser Protokolldatei angezeigt werden - obwohl sie in diesem Fall nicht mehr nicht mehr sind. Bitte denken Sie daran, dass dieser Code mein allererster geschriebener Python -Code war, also können die Dinge, gelinde gesagt, "ungewöhnlich" aussehen und dass ich im wirklichen Leben kein Programmierer bin. Ich benutze nur Python, um meine Wissenschaft zu machen.

Code: Select all

#!/usr/bin/env /home/pisti/.venv/3.12.8/bin/python

import argparse
import asyncio
import atexit
import exifread
import fnmatch
import getpass
import glob
import hashlib                  # needed 
import inspect
import logging
import logging.handlers
import math
import multiprocessing
import nest_asyncio             # needed 
nest_asyncio.apply()            # needed 
import os
import pudb
import shelve
import shutil
import signal
import socket
import string
import subprocess
import sys
import time
import webbrowser
import websockets

from PIL import Image
from PIL.ExifTags import GPSTAGS
from PIL.ExifTags import TAGS
from PIL.Image import core as _imaging
from datetime import datetime
from pathlib import Path
from string import Template
from time import strftime

os.environ['PYTHONASYNCIODEBUG'] = '1'

# logger *******************************
homedir = os.path.expanduser("~")
programName = 'fm'
LOGfile = os.path.join( homedir , '.' + programName + '.log')
logger = logging.getLogger(__name__)
logger = logging.getLogger('websockets.server')
logger.setLevel( logging.DEBUG) # NOTSET INFO
filehandler = logging.handlers.TimedRotatingFileHandler( LOGfile, when='midnight', interval=1, backupCount=10)
filehandler.setFormatter( logging.Formatter( fmt='%(asctime)s %(levelname)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S'))
logger.addHandler( filehandler)
logger.addHandler( logging.StreamHandler())

# main #################################
def main():

SysArgv = sys.argv[1:]
while len( SysArgv) != 0:
if SysArgv[0][0:2] == '-v':
SysArgv = SysArgv[1:]
else:
break
SysArgvL = len( SysArgv)

try:
me
except NameError:
me = fmSetup( args.verbose)

#### DAEMON ------------------------
daemon = fmDaemon( me)

#### INPUT args --------------------
if SysArgvL == 0:
if me.verbose > 0: fmInfo( me)
daemon.start()
sys.exit(0)

elif SysArgvL == 1:
if SysArgv[0] == 'start':
if me.verbose > 0: fmInfo( me)
daemon.start()
elif SysArgv[0] == 'restart':
daemon.restart()
elif SysArgv[0] == 'status':
daemon.status()
elif SysArgv[0] == 'stop':
fmStop( me, daemon)
elif SysArgv[0] == 'version':
fmVersion( me)

#### websocket calls
elif SysArgv[0] == 'info':
fmInfo( me)
fmWebsocketClientSend( me, 'info')
elif SysArgv[0] == 'load':
fmWebsocketClientSend( me, 'load')
elif SysArgv[0] == 'rebuild':
fmWebsocketClientSend( me, 'rebuild')
elif SysArgv[0] == 'save':
fmWebsocketClientSend( me, 'save')
elif SysArgv[0] == 'merge':
fmWebsocketClientSend( me, 'merge')
elif SysArgv[0] == 'quit':
fmWebsocketClientSend( me, 'quit')

#### websocket default calls
elif SysArgv[0] == 'uid':
fmWebsocketClientSend( me, 'uid default')
elif SysArgv[0] == 'list':
fmWebsocketClientSend( me, 'list default')
elif SysArgv[0] == 'import':
fmWebsocketClientSend( me, 'import default')
elif SysArgv[0] == 'export':
fmWebsocketClientSend( me, 'export default')
elif SysArgv[0] == 'test':
fmWebsocketClientSend( me, 'test default')
elif SysArgv[0] == 'www':
fmWebsocketClientSend( me, 'www default')
else:
print ( "Unknown command")
sys.exit(2)

sys.exit(0)

elif SysArgvL >  1:

msg = ' '.join( SysArgv)
fmWebsocketClientSend( me, msg)
sys.exit(0)

else:
sys.exit(2)

return SysArgv

# fmSetup ##############################
class fmSetup( object):
def __init__( self, verbose):
define tons of self stuff...
define tons of self stuff...
define tons of self stuff...

# Daemon ###############################
class Daemon( object):

def __init__( self, me):
self.me = me

def daemonize( self):
print("daemonizing")

try:
pid = os.fork()
if pid > 0:
# exit first parent
sys.exit(0)
except OSError as err:
sys.stderr.write( 'fork #1 failed: {0}\n'.format(err))
sys.exit(1)

# decouple from parent environment
os.chdir('/')
os.setsid()
os.umask(0)

# do second fork
try:
pid = os.fork()
if pid > 0:
# exit from second parent
sys.exit(0)
except OSError as err:
sys.stderr.write('fork #2 failed: {0}\n'.format(err))
sys.exit(1)

fmAfterDaemonStarted( self.me)

# redirect standard file descriptors
sys.stdout.flush()
sys.stderr.flush()
si = open( os.devnull, 'r')
so = open( os.devnull, 'a+')
se = open( os.devnull, 'a+')

os.dup2( si.fileno(), sys.stdin.fileno())
os.dup2( so.fileno(), sys.stdout.fileno())
os.dup2( se.fileno(), sys.stderr.fileno())

# write pidfile
atexit.register( self.delpid)

pid = str( os.getpid())
with open( self.me.PIDfile,'w+') as f:
f.write(pid + '\n')

def delpid( self):
os.remove( self.me.PIDfile)

def start( self):
"""Start the daemon."""
print("daemon start")

# Check for a pidfile to see if the daemon already runs
try:
with open( self.me.PIDfile,'r') as pf:

pid = int( pf.read().strip())
except IOError:
pid = None

if pid:
message = "pidfile {0} already exist. " + \
"Daemon already running?\n"
sys.stderr.write( message.format( self.me.PIDfile))
sys.exit(1)

# Start the daemon
self.daemonize()
self.run()      #### 

def stop( self):
print("daemon stop")

# Get the pid from the pidfile
try:
with open( self.me.PIDfile,'r') as pf:
pid = int( pf.read().strip())
except IOError:
pid = None

if not pid:
message = "pidfile {0} does not exist.  " + \
"Daemon not running?\n"
sys.stderr.write( message.format( self.me.PIDfile))
return

# Try killing the daemon process
try:
while 1:
os.kill( pid, signal.SIGTERM)
time.sleep( 0.1)
except OSError as err:
e = str( err.args)
if e.find( "No such process") > 0:
if os.path.exists( self.me.PIDfile):
os.remove( self.me.PIDfile)
else:
print( str( err.args))
sys.exit(1)

def restart( self):
print("daemon restart")
self.stop()
time.sleep(1)
self.start()

# fmDaemon #############################
class fmDaemon( Daemon):
def __init__( self, me):
self.me = me

def run( self):
while True:
async def coroutine_daemon_websocket_server( websocket):

logger.debug('{}{} {} {}{}'.format( "\033[1;34m", sys.argv[0], Lstr, "- in Daemon while loop !", "\033[1;0m"))

# --- CODE and LOGs STOP HERE !!! ---

# RECV -----------------
msg = await websocket.recv()

# SEND -----------------
if msg != None:
msg_out = "{}".format( msg)
await websocket.send( msg_out)

fmProcessor( self.me, msg)

start_server        = websockets.serve( coroutine_daemon_websocket_server, self.me.IP, self.me.PORT)
asyncio.get_event_loop().run_until_complete( start_server)
asyncio.get_event_loop().run_forever()
asyncio.get_event_loop().close()

# fmWebsocketClientSend ################
def fmWebsocketClientSend( me, msg):
async def coroutine_websocket_client():
async with websockets.connect( 'ws://{}:{}/'.format( me.IP, me.PORT)) as websocket:
await websocket.send( msg)
rcvd = await websocket.recv()
asyncio.get_event_loop().run_until_complete( coroutine_websocket_client())

# functions ############################
def fmAfterDaemonStarted( me):
do stuff...

def fmQuit( me):
if 'chrome' in me.WebBrowser[0].lower():
if os.path.isdir( me.ChromeCachePIDdir):
shutil.rmtree( me.ChromeCachePIDdir)
sys.exit(0)

def fmStop( me, daemon):
do hard stop...
daemon.stop()
sys.exit(0)

def manyMoreFunctions()...
stuff to do...

if __name__ == "__main__":
main()
else:
main()
< /code>
Addendum: Guter Punkt, @Tangential senkrecht!  NOP, danach werden keine Fehlermeldungen oder neue Protokollzeilen generiert.  Danach nur zum Schweigen, einfach nichts, nada! < /p>
...
2025-04-05 21:50:47 DEBUG /home/pisti/programs/bin/fm fmHTMLopening - calling webbrowser
2025-04-05 21:50:47 DEBUG /home/pisti/programs/bin/fm fmHTMLopening - done.
2025-04-05 21:50:47 DEBUG /home/pisti/programs/bin/fm fmAfterDaemonStarted - done.
2025-04-05 21:50:47 DEBUG /home/pisti/programs/bin/fm fmDaemon - in Daemon while loop !