[ TAG 241 ][18.12.2021] -Erfolgreich -IAP-20210601-20210722

Ich beginne die Worksession um [18.12.2021][1235]. Der erste Punkt meiner Worksession für heute ist es ein Ziel für heute zu definieren.

Heute werde ich mit zwei Modulen arbeiten.

• RPRCSL_20211212_1520.py
• PROCESS_ALOG_20210726_0110.py

Die [RPRCSL] soll erweitert werden. Der [RPRCSL_ITEM]-Item soll alle nötigen Informationen bzw. Daten beinhalten, die der ALOG-PROZESS benötigt.

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)

Folgende Daten sehe ich aus der jetzigen Perspektive. Diese können in die [RPRCSL] aufgenommen werden.

• logger_str_idnt
• logger_prj_idnt
• logger_p11_spi
• -----------------
• alog_str_idnt
• alog_prj_idnt
• alog_p11_spi

Diese Daten ergeben sich aus den [PRTKL_202112082120]-Protokoll. Um die Ordner-Struktur nach [PRTKL-202112082120] umzusetzen, benötige ich folgende Daten.

• STORAGE_IDENTIFIER
• PROJECT_IDENTIFIER
• SUBPROJECT_IDENTIFIER

Der STORAGE_IDENTIFIER kurz [str_idnt] beinhaltet die Bezeichnung bzw. den Namen der Festplatte.

Der PROJECT_IDENTIFIER kurz [prj_idnt] beinhaltet eine kurze Projektbezeichnung. Zum Beispiel "ALOG" oder "LOGGER".

Unter der kurzen Projektbezeichnung "ALOG" werden Audiodaten geführt. Die kurze Projektbezeichnung "LOGGER" beinhaltet Textdateien, in denen unterschiedliche Statusmeldungen geführt werden.

Der SUBPROJECT_IDENTIFIER beinhaltet eine kurze Projektbezeichnung, die die Zugehörigkeit der Dateien beschreibt. Die Audio-Dateien bzw. ALOGs gehören zu den Projekt "DEON". Somit wäre der SUBPROJECT_IDENTIFIER "DEON".

Der nächste Punkt über den ich nachdenke, besteht darin die Pfade im Hauptprozess zu generieren und diese wiederum als Zeichenketten über die [RPRCSL]-Liste den ALOG-Prozessen weiter zu geben.

Die nächsten Erweiterungen an der [RPRCSL]-Liste werden das SHARED-MEMORY-MODUL kurz SHM betreffen.

Heute werde ich mich jedoch auf folgende Daten konzentrieren.

• logger_str_idnt
• logger_prj_idnt
• logger_p11_spi
• -----------------
• alog_str_idnt
• alog_prj_idnt
• alog_p11_spi

Der erste Schritt besteht für mich darin den [LOGGER-0] kurz [L0] zu definieren. Aus der jetzigen Perspektive sehe ich die Anwendungsgebiete von [L0] nur im [PROCESS_ALOG_20210726_0110]-MODUL.

[L0]-Aufgabe

Die Aufgabe von [L0] besteht darin die Ausführung des ALOG-PROZESSES zu protokollieren. Mit den protokollieren Daten können zum Beispiel Zeit-Messungen vorgenommen werden. Es können Timestemps protokolliert werden. Man kann dann sehen wann welcher Prozess ausgeführt wurde. Man kann die Ausführungsdauer protokollieren. Somit kann man sich ein detailliertes Bild über die internen Vorgänge verschaffen.

Zu diesen Zeitpunkt habe ich bereits einen leeren Dummy für folgende Daten bereits geschaffen.

• logger_str_idnt
• logger_prj_idnt
• logger_p11_spi

Hier sind einige Auszüge aus dem Modul [RPRCSL_20211212_1520]

def LOGGER_ITEM(idnt, pth):
    i = dict()
    i["idnt"] = idnt
    i["pth"] = pth
    i["str_idnt"] = None
    i["prj_idnt"] = None
    i["p11_spi"] = None
    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,
        alog=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,
    i["alog"] = alog
    return i

def RPRCSL_ADD(rprcsl, pid, idnt, pth):
    p = psutil.Process(pid)
    with p.oneshot():
        rprcsl[pid] = RPRCSL_ITEM(
            name=p.name(),
            pid=p.pid,
            ppid=p.ppid(),
            status=p.status(),
            create_time_0=p.create_time(),
            create_time_1=datetime.datetime.fromtimestamp(p.create_time()).strftime("%Y-%m-%d %H:%M:%S"),
            closed_time_0=None,
            closed_time_1=None,
            logger_0=LOGGER_ITEM(idnt, pth),
            alog=ALOG_ITEM(str_idnt=None, prj_idnt=None, p11_spi=None)
        )

Ich habe bereit zu diesen Zeitpunkt einen [LOGGER-ITEM] im Modul [RPRCSL_20211212_1520] mit folgenden Dictionary(Assoziativen Array) definiert.

• i["idnt"]
• i["pth"]
• i["str_idnt"]
• i["prj_idnt"]
• i["p11_spi"]

Das Element ["idnt"] beinhaltet den FILE_IDENTIFIER aus dem Protokoll [PRTKL_202111090330]. Der IDENTIFIER ["idnt"] wird für Dateinamen benutzt.

Das Element ["pth"] beinhaltet den generierten Pfad als Zeichenkette. Der Pfad wird von unten aufgelisteten Protokollen generiert.

• PRTKL_202110140000
• PRTKL_202111090330
• PRTKL_202112082120

Diese Protokolle arbeiten mit der Path-Library von Python. Um einen Pfad bzw. die Ordnerstruktur zu beschreiben benötige ich eigentlich nicht mehr Daten. Zu diesen Zeitpunkt finde ich es auch kontraproduktiv einzelne IDENTIFIER aus den oben aufgelisteten Protokollen in das RPRCSL-ITEM aufzunehmen. Vor allem, dass die Daten bereits alle im Pfad kodiert sind. Jedoch müssen diese Daten, dann aus dem i["pth"] extrahiert werden.

def RPRCSL_ADD(
        rprcsl,
        pid,
        l0_idnt,
        l0_pth,
        l0_str_idnt,
        l0_prj_idnt,
        l0_p11_spi,
        alog_idnt,
        alog_pth,
        alog_str_idnt,
        alog_prj_idnt,
        alog_p11_spi
               ):
    p = psutil.Process(pid)
    with p.oneshot():
        rprcsl[pid] = RPRCSL_ITEM(
            name=p.name(),
            pid=p.pid,
            ppid=p.ppid(),
            status=p.status(),
            create_time_0=p.create_time(),
            create_time_1=datetime.datetime.fromtimestamp(p.create_time()).strftime("%Y-%m-%d %H:%M:%S"),
            closed_time_0=None,
            closed_time_1=None,
            logger_0=LOGGER_ITEM(idnt=l0_idnt, pth=l0_pth, str_idnt=l0_str_idnt, prj_idnt=l0_prj_idnt, p11_spi=l0_p11_spi),
            alog=ALOG_ITEM(idnt=alog_idnt, pth=alog_pth, str_idnt=alog_str_idnt, prj_idnt=alog_prj_idnt, p11_spi=alog_p11_spi)
        )

[18.12.2021][2331] - Ich bin auf ein Problem gestoßen. Das Problem wird von [psutil] verursacht.

p = psutil.Process(pid)

Wenn ich die Methode [RPRCSL_ADD(...)] aus dem Child-Process (ALOG-Methode) ausführe, so funktioniert [psutil] sehr gut. Wenn ich jedoch aus dem Main-Process bzw. Parent-Process die Methode ausführe und diese nach der [.start()]-Methode platziere. Dann wurde der Prozess wenn die Zeile ausgeführt wird noch nicht gestartet. Die Methode [psutil.pid_exists(pid)] gibt False zurück.

def RPRCSL_ADD(
        rprcsl=None,
        pid=None,
        l0_idnt=None,
        l0_pth=None,
        l0_str_idnt=None,
        l0_prj_idnt=None,
        l0_p11_spi=None,
        alog_idnt=None,
        alog_pth=None,
        alog_str_idnt=None,
        alog_prj_idnt=None,
        alog_p11_spi=None
               ):
    if rprcsl is None:
        return False
    if pid is None:
        return False
    if psutil.pid_exists(pid) is False:
        return False
    p = psutil.Process(pid)
    print(f"p:{p}")
    with p.oneshot():
        rprcsl[pid] = RPRCSL_ITEM(
            name=p.name(),
            pid=p.pid,
            ppid=p.ppid(),
            status=p.status(),
            create_time_0=p.create_time(),
            create_time_1=datetime.datetime.fromtimestamp(p.create_time()).strftime("%Y-%m-%d %H:%M:%S"),
            closed_time_0=None,
            closed_time_1=None,
            logger_0=LOGGER_ITEM(idnt=l0_idnt, pth=l0_pth, str_idnt=l0_str_idnt, prj_idnt=l0_prj_idnt, p11_spi=l0_p11_spi),
            alog=ALOG_ITEM(idnt=alog_idnt, pth=alog_pth, str_idnt=alog_str_idnt, prj_idnt=alog_prj_idnt, p11_spi=alog_p11_spi)
        )