[ TAG 237 ][14.12.2021] -Erfolgreich -IAP-20210601-20210722

Ich beginne meine heutige Worksession mit einen grundlegenden Problem.

Ich habe die Methoden [ALOG] und [START_PROCESS].

def ALOG(rprcsl):
    pid = os.getpid()
    RPRCSL_20211212_1520.RPRCSL_ADD(rprcsl, pid)

    logger_str_idnt="ext_prj_2021"
    logger_prj_idnt = "LOGGER"
    logger_p11_spi = "DEON"
    logger_pth = prtkl_202112082120.ini(str_idnt=logger_str_idnt, prj_idnt=logger_prj_idnt, p11_spi=logger_p11_spi)

    alog_str_idnt = "ext_prj_2021"
    alog_prj_idnt = "ALOG"
    alog_p11_spi = "DEON"
    alog_pth = prtkl_202112082120.ini(str_idnt=alog_str_idnt, prj_idnt=alog_prj_idnt, p11_spi=alog_p11_spi)

    lgr = INIT_LOGGER(prtkl=logger_pth, pid=pid)

    lgr.debug("ALOG-Prozess wurde gestartet.")
    lgr.debug("LOGGER-IDENTIFIER")
    lgr.debug(f"logger_str_idnt: {logger_str_idnt}")
    lgr.debug(f"logger_prj_idnt: {logger_prj_idnt}")
    lgr.debug(f"logger_p11_spi: {logger_p11_spi}")
    lgr.debug("logger_idnt: " + logger_pth["idnt"])
    lgr.debug(f"logger_pth['pth'].resolve(): {logger_pth['pth'].resolve()}")
    lgr.debug(f"---------------------------------------------------")
    lgr.debug("ALOG-IDENTIFIER")
    lgr.debug(f"alog_str_idnt: {alog_str_idnt}")
    lgr.debug(f"alog_prj_idnt: {alog_prj_idnt}")
    lgr.debug(f"alog_p11_spi: {alog_p11_spi}")
    lgr.debug("alog_idnt: " + logger_pth["idnt"])
    lgr.debug(f"alog_pth['pth'].resolve(): {alog_pth['pth'].resolve()}")
    lgr.debug(f"---------------------------------------------------")
    lgr.debug(f"name: {rprcsl[pid]['name']}")
    lgr.debug(f"pid: {rprcsl[pid]['pid']}")
    lgr.debug(f"ppid: {rprcsl[pid]['ppid']}")
    lgr.debug(f"status: {rprcsl[pid]['status']}")
    lgr.debug(f"create_time_0: {rprcsl[pid]['create_time_0']}")
    lgr.debug(f"create_time_1: {rprcsl[pid]['create_time_1']}")

    i = 0
    while i > 100000:
        i += 1

    RPRCSL_20211212_1520.RPRCSL_EVNT_CLOSE(rprcsl, pid, RPRCSL_20211212_1520.RPRCSL_COPY(rprcsl, pid))
    lgr.debug(f"closed_time_0: {rprcsl[pid]['closed_time_0']}")
    lgr.debug(f"closed_time_1: {rprcsl[pid]['closed_time_1']}")
    lgr.debug(f"life_time_sec_0: {rprcsl[pid]['life_time_sec_0']}")


def START_PROCESS(alog_glb):
    print(f"START_PROCESS -> START_PROCESS(alog_glb) wird ausgeführt.")
    p = Process(target=ALOG, args=(alog_glb.RPRCSL,))
    p.start()
    p.join()
    print(f"START_PROCESS -> alog_glb.RPRCSL: {alog_glb.RPRCSL}")

Das Problem besteht in erster Linie darin, dass am Ende dieser Methode, den Status "run" hat. Es sind zwar die letzten Ausführungszeilen, jedoch werden Sie in diesen Prozess abgearbeitet.

Ich habe das Python-Modul [RPRCSL_LOGGER_20210929.py]. Das Modul ist für die Generierung eines Logger verantwortlich.

Was ich bisher in Erfahrung bringen konnte, sind LOGGER in der Lage über ihren Identifikationsnamen sich zu verbinden.

Eine Eigenschaft, die ich sehr merkwürdig finde besteht darin, dass ich den LOGGER nicht schließen kann.

Ich konnte erfolgreich die StreamHandler und die FileHandler entfernen. Jedoch konnte ich den Logger selbst mit [loggin.shutdown()] nicht schließen. Zu diesen Zeitpunkt verstehe ich dieses Problem noch nicht. Ich habe über dieses Problem ein wenig recherchiert und ich glaube ich verstehe die Funktionsweise des [loggin]-Moduls nicht richtig.

Das [loggin]-Modul ist sehr viel komplexer als ich angenommen habe. Mich hat ein Eigenschaft zu tiefst überrascht, als ich das [loggin]-Modul und deren Listung der Logger erforscht habe.

Mir ist dabei aufgefallen, dass das Punk-Symbol im Namen des Loggers eine sehr wichtige Rolle spielt. Es scheint so, dass das [loggin]-Modul automatisch und intern mehrere Logger anlegt. Wenn ich einen Namen mit drei Punkten habe, erstellt das [loggin]-Modul automatisch drei Logger-Objekte. Ich habe dieses Verhalten von [loggin]-Modul nicht vorhergesehen. Jedoch hatte ich glücklicherweise die Generierung der Zeichenketten für den Logger-Namen und den Datei-Namen getrennt. Den Punkt als Delimiter zu verwenden war keine gute Idee. Jedoch konnte ich diese Eigenschaft damals nicht vorhersehen.

Hier ist noch einmal der Fehler, den ich bei der Benennung gemacht habe.

def LOGGER_NAME(idnt, pid):
    #return f"{idnt}|{pid}|rprcsl"
    return f"{idnt}.{pid}.rprcsl"

Ausgabe:

{

'DEON_20211214_2358-0.16724.rprcsl': <Logger DEON_20211214_2358-0.16724.rprcsl (DEBUG)>, 

'DEON_20211214_2358-0.16724': <Logger DEON_20211214_2358-0.16724 (WARNING)>, 

'DEON_20211214_2358-0': <Logger DEON_20211214_2358-0 (WARNING)>

}

Hier ist es jetzt richtig. Die Methode [LOGGER_NAME(idnt, pid)] wurde korrigiert.

def LOGGER_NAME(idnt, pid):
    return f"{idnt}|{pid}|rprcsl"
    #return f"{idnt}.{pid}.rprcsl"

Ausgabe:

{

'DEON_20211215_0000-0|11728|rprcsl': <Logger DEON_20211215_0000-0|11728|rprcsl (DEBUG)>

}

Die Auflistung der vorhandene Logger ist eine wichtige Funktion. Deswegen habe ich zwei neue Funktionen programmiert.

• GET_LOGGERLIST_NAME()
• GET_LOGGERLIST()
• HAS_LOGGER(name)

def GET_LOGGERLIST_NAME():
    loggers = [name for name in logging.root.manager.loggerDict]
    return loggers


def GET_LOGGERLIST():
    loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict]
    return loggers


def HAS_LOGGER(name=""):
    loggers = [name for name in logging.root.manager.loggerDict]
    if name in loggers:
        return True
    else:
        return False

Die nächste Ergänzung, die ich heute realisiert habe, befindet sich im Modul [RPRCSL_20211212_1520.py]. Ich habe der [RPRCSL]-Liste ein neues Element hinzugefügt. Dieses Element ist für den LOGGER gedacht. Weil ich zu diesen Zeitpunkt davon ausgehe, dass es mehrere Logger in Zukunft sein könnten, habe ich dem Namen des Elementes eine "0" hinzugefügt. Zu diesem Zeitpunkt habe ich bisher nur einen Logger. Jedoch möchte ich das System flexibler halten und mir die Option offen lassen weitere Logger in die Prozesse zu installieren.

def LOGGER_ITEM(idnt, pth):
    i = dict()
    i["idnt"] = idnt
    i["pth"] = pth
    return i

def RPRCSL_ITEM(
        name=None,
        pid=None,
        ppid=None,
        status=None,
        create_time_0=None,
        create_time_1=None,
        closed_time_0=None,
        closed_time_1=None,
        life_time_sec_0=None,
        logger_0=None
):
    i = dict()
    i["name"] = name
    i["pid"] = pid
    i["ppid"] = ppid
    i["status"] = status
    i["create_time_0"] = create_time_0
    i["create_time_1"] = create_time_1
    i["closed_time_0"] = closed_time_0
    i["closed_time_1"] = closed_time_1
    i["life_time_sec_0"] = life_time_sec_0
    i["logger_0"] = logger_0
    return i

Dieses Element soll die Kommunikation zwischen den Elternprozess und Kindprozess ermöglichen. Das Kindprozess repräsentiert die Methode [ALOG()]. Bei den Elternprozess ist es die Methode [START_PROCESS()]. Diese Kommunikation werde ich in den kommenden Tagen verbessern.

def INIT_LOGGER(idnt=None, pth=None, pid=None):
    rprcsl_log.INIT(
        idnt=idnt,
        path=pth,
        pid=pid
    )
    return rprcsl_log.RPRCSL_LOGGER


def SHUTDOWN_LOGGER():
    rprcsl_log.SHUTDOWN()


def ALOG(rprcsl):
    pid = os.getpid()

    logger_str_idnt="ext_prj_2021"
    logger_prj_idnt = "LOGGER"
    logger_p11_spi = "DEON"
    logger_pth = prtkl_202112082120.ini(str_idnt=logger_str_idnt, prj_idnt=logger_prj_idnt, p11_spi=logger_p11_spi)
    RPRCSL_20211212_1520.RPRCSL_ADD(rprcsl, pid, logger_pth["idnt"], f"{logger_pth['pth'].resolve()}")

    alog_str_idnt = "ext_prj_2021"
    alog_prj_idnt = "ALOG"
    alog_p11_spi = "DEON"
    alog_pth = prtkl_202112082120.ini(str_idnt=alog_str_idnt, prj_idnt=alog_prj_idnt, p11_spi=alog_p11_spi)

    lgr = INIT_LOGGER(idnt=logger_pth["idnt"], pth=f"{logger_pth['pth'].resolve()}", pid=pid)

    lgr.debug("ALOG-Prozess wurde gestartet.")
    lgr.debug("LOGGER-IDENTIFIER")
    lgr.debug(f"logger_str_idnt: {logger_str_idnt}")
    lgr.debug(f"logger_prj_idnt: {logger_prj_idnt}")
    lgr.debug(f"logger_p11_spi: {logger_p11_spi}")
    lgr.debug("logger_idnt: " + logger_pth["idnt"])
    lgr.debug(f"logger_pth['pth'].resolve(): {logger_pth['pth'].resolve()}")
    lgr.debug(f"---------------------------------------------------")
    lgr.debug("ALOG-IDENTIFIER")
    lgr.debug(f"alog_str_idnt: {alog_str_idnt}")
    lgr.debug(f"alog_prj_idnt: {alog_prj_idnt}")
    lgr.debug(f"alog_p11_spi: {alog_p11_spi}")
    lgr.debug("alog_idnt: " + logger_pth["idnt"])
    lgr.debug(f"alog_pth['pth'].resolve(): {alog_pth['pth'].resolve()}")
    lgr.debug(f"---------------------------------------------------")
    lgr.debug(f"name: {rprcsl[pid]['name']}")
    lgr.debug(f"pid: {rprcsl[pid]['pid']}")
    lgr.debug(f"ppid: {rprcsl[pid]['ppid']}")
    lgr.debug(f"status: {rprcsl[pid]['status']}")
    lgr.debug(f"create_time_0: {rprcsl[pid]['create_time_0']}")
    lgr.debug(f"create_time_1: {rprcsl[pid]['create_time_1']}")

    i = 0
    while i > 100000:
        i += 1

    RPRCSL_20211212_1520.RPRCSL_EVNT_CLOSE(rprcsl, pid, RPRCSL_20211212_1520.RPRCSL_COPY(rprcsl, pid))
    lgr.debug(f"closed_time_0: {rprcsl[pid]['closed_time_0']}")
    lgr.debug(f"closed_time_1: {rprcsl[pid]['closed_time_1']}")
    lgr.debug(f"life_time_sec_0: {rprcsl[pid]['life_time_sec_0']}")

    lg2 = rprcsl_log.CONNECT(logger_pth["idnt"], pid)
    lg2.debug(f"TEST.TEST.TEST")
    print("")
    print("")
    print(rprcsl_log.GET_LOGGERLIST())
    print(rprcsl_log.GET_LOGGERLIST_NAME())
    print(rprcsl_log.HAS_LOGGER(lg2.name))




def START_PROCESS(alog_glb):
    print(f"START_PROCESS -> START_PROCESS(alog_glb) wird ausgeführt.")
    p = Process(target=ALOG, args=(alog_glb.RPRCSL,))
    p.start()
    pid = p.pid
    print(f"----------------pid:{p.pid}")
    p.join()
    print(f"START_PROCESS -> alog_glb.RPRCSL: {alog_glb.RPRCSL}")
    print(rprcsl_log.GET_LOGGERLIST())
    print(rprcsl_log.GET_LOGGERLIST_NAME())
    print(alog_glb.RPRCSL[pid])
    print(alog_glb.RPRCSL[pid]["logger_0"]["idnt"])
    print(alog_glb.RPRCSL[pid]["logger_0"]["pth"])
    lgr = INIT_LOGGER(idnt=alog_glb.RPRCSL[pid]["logger_0"]["idnt"], pth=alog_glb.RPRCSL[pid]["logger_0"]["pth"], pid=pid)
    lgr.debug(f"ENDE")