einfacher CGIHTTPServer mit Python realisieren.

[jens]

Zum lokalen Testen von Webseiten/CGI kann man mit Python einen eigenen Webserver einfach aufmachen...

Einfach den Pfad in chdir() ändern, oder das chdir() auskommentieren und das ganze Skript in's Root-Verzeichnis deiner lokalen kopie der Webseite kopieren und von da aus Starten. Dann kann man mit dem Browser den Server mit der URL "http://localhost" erreichen...

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: ISO-8859-1 -*-

import CGIHTTPServer
import BaseHTTPServer
import os, sys
import webbrowser

# Zum Root-Verzeichnis der Webseite wechseln
# (Das Verz. mit der Einstiegts-"index.html" Seite)
os.chdir("/daten/MeineWebseite")

# Verz. in dem CGIs ausgeführt werden sollen. Leer lassen (="") für alle Verz.
cgiVerz = ""

# Port auf dem der Server anfragen entgegen nehmen soll.
ListenPort = 80

# Umgebungsvariablen setzten, die man in CGI-Skripten abfragen kann und normalerweise
# von einem echten WebServer automatisch gesetzt werden
# Evtl. selber erweitern ;)
os.environ['DOCUMENT_ROOT']=os.getcwd()
os.environ['HTTP_USER_AGENT']="Mozilla/5.0 (Windows; U; Windows NT 5.1; de-DE; rv:1.7.5) Gecko/20041108 Firefox/1.0"
os.environ['HTTP_HOST']="localhost"
os.environ['REMOTE_ADDR']="localhost"


class MyHandler(CGIHTTPServer.CGIHTTPRequestHandler):
    "Modifizieren des Ursprünglichen Servers"

    print "Lese Verzeichnisbaum für CGI-Ausführung...",
    # Liste aller Unetrverzeichnisse erzeugen, damit überall CGIs ausgeführt werden.
    cgi_directories = ["/"+i[0].replace("\\","/") for i in os.walk(cgiVerz)]
    print "OK",len(cgi_directories),"Verz. gefunden\n"

    def is_python(self, path):
        "Endungen, die als Python-Skript ausgeführt werden sollen."
        head, tail = os.path.splitext(path)
        return tail.lower() in (".py", ".pyw", ".cgi")

    def is_cgi(self):
        "Ausführen eines Python-Skript"
        path = self.path
        for x in self.cgi_directories:
            i = len(x)
            if path[:i] == x and (path[i+1:] and path[i] == '/'):
                self.cgi_info = path[:i], path[i+1:]
                return True
        return False


httpd = BaseHTTPServer.HTTPServer(("", ListenPort), MyHandler)

print "ROOT-Pfad:", os.getcwd()
print "Starte CGI-HTTP-Server auf Port",ListenPort
print "Seiten sind nun unter [http://localhost:%s] erreichbar!\n" % ListenPort

# Öffne Browser
webbrowser.open_new("http://localhost")

httpd.serve_forever()

[Dookie]

Hi jens,

Code: Alles auswählen

import webbrowser

webbrowser.open_new("http://localhost")

Gruß

Dookie

[jens]

Aha... Dann bau ich das mal ein... Danke!

[Milan]

Verbesserung füür den Server, damit er mehrere Anfragen parallel bearbeiten kann:

Code: Alles auswählen

import SocketServer,socket
class MyServer(SocketServer.ThreadingTCPServer):
    allow_reuse_address = 1    # Seems to make sense in testing environment
    def server_bind(self):
        """Override server_bind to store the server name."""
        SocketServer.ThreadingTCPServer.server_bind(self)
        host, port = self.socket.getsockname()[:2]
        self.server_name = socket.getfqdn(host)
        self.server_port = port

Einfach anstelle von BaseHTTPServer.HTTPServer nutzen...

[jens]

Super, wobei ich jetzt nicht genau was "mehrere Anfragen parallel bearbeiten" in der Praxis heißt...
Da es aber nur so'n kleines Stückchen Code ist, frage ich mich, warum es schon so eingebaut ist...

[Leonidas]

Super, wobei ich jetzt nicht genau was "mehrere Anfragen parallel bearbeiten" in der Praxis heißt...

Das man beispielsweise zwei Downloads gleichzeitig von dem Server bekommen kann, was sonst ja nicht möglich wäre, der würde sonst so lange blokieren, bis der erste fertig ist.

[jens]

Also durchaus Sinnvoll, würde ich mal meinen Ob das irgendwann mal zum Standart gehöhrt???

Ich hab es eingebaut, wobei ich da noch Probleme an andere Stelle hab, s. http://python.sandtner.org/viewtopic.php?p=16069#16069

[Leonidas]

Also durchaus Sinnvoll, würde ich mal meinen Ob das irgendwann mal zum Standart gehöhrt???

Tut es doch. Ist doch in SocketServer drin.

[jens]

Hab nochmal die alten Quellentexte rausgekramt... Dabei ist mit aufgefallen, das os.environ["QUERY_STRING"] nicht richtig gesetzt war... Somit klappte es nicht einen lokalen PyLucid-Test zu fahren... Nun geht's aber...

Wenn ich jetzt dem Server noch beibringen kann, die ErrorDocument aus der htaccess-Datei auszuwerten, könnte es auch mit PyLucid's poormans_modrewrite klappen...

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: ISO-8859-1 -*-

__version__ = "0.0.5"

__history__ = """
v0.0.5
    - os.environ["QUERY_STRING"] wird richtig übergeben
"""


import CGIHTTPServer, SocketServer
import os, sys, time, socket


class RedirectStdOut:
    def __init__( self, File, stdoutObj ):
        self.MyStdOut = stdoutObj
        self.File = File

    def write( self, *txt ):
        txt = " ".join([str(i) for i in txt])
        # Auf Konsole Ausgeben
        self.MyStdOut.write( txt )
        # In Log-Datei schreiben
        FileHandle = file( self.File, "a" )
        FileHandle.write( txt )
        FileHandle.close()


class MyRequestHandler( CGIHTTPServer.CGIHTTPRequestHandler ):
    "Modifizieren des Standart RequestHandlers"

    # Damit auch unter Linux, welches fork unterstützt, das Python-CGI-Skript
    # unter dem User ausgeführt wird, mit dem der CGIHTTPServer gestartet wurde
    # und nicht mit User nobody...
    have_fork = False
    have_popen2 = False
    have_popen3 = False

    def is_cgi(self):
        "Modifikation, sodas man im CGI-Verzeichnis ein Dir-Listing bekommt"

        try:
            self.path, query_string = self.path.split("?",1)
        except ValueError:
            query_string = ""

        base, file = os.path.split( self.path )
        if file=="": return False

        base = os.path.normpath( base )
        for x in self.cgi_directories:
            if x == base:
                self.cgi_info = base, file+"?"+query_string
                os.environ['SCRIPT_FILENAME'] = file
                return True
        return False



class MyThreadingServer( SocketServer.ThreadingTCPServer ):
    """
    Verbesserung des Standart Servers:
     - ermöglicht das abarbeiten mehrere Anfragen parallel (z.B. Download mehrere Dateien gleichzeitig)
     - Ermöglicht das einschränken des IP-Bereiches aus denen der Server Anfragen behandelt
    """
    allow_reuse_address = 1    # Seems to make sense in testing environment

    def __init__(self, server_address, request_handler, AllowIPs):
        SocketServer.ThreadingTCPServer.__init__(self, server_address, request_handler)
        self.AllowIPs = [mask.split('.') for mask in AllowIPs]

    def server_bind(self):
        """Override server_bind to store the server name. (Parallele Anfragen)"""
        SocketServer.ThreadingTCPServer.server_bind(self)
        host, port = self.socket.getsockname()[:2]
        self.server_name = socket.getfqdn(host)
        self.server_port = port

    def verify_request(self, dummy, client_address):
        """Checkt ob die IP-Adresse der Anfrage in 'AllowIPs' vorhanden ist"""
        def check_ip(mask):
            for mask_part, ip_part in zip(mask, ip):
                if mask_part != ip_part and mask_part != '*':
                    return False
            return True

        ip = client_address[0].split('.')

        for mask in self.AllowIPs:
            if check_ip(mask):
                return True

        print "IP [%s] not allowed!" % client_address

        # Beugt DOS Attacken vor, in dem die Rückmeldung verzögert und
        # somit CPU-Zeit freigegeben wird.
        time.sleep(1)

        return False




def ServerStart( cgiVerz, ListenPort, AllowIPs, LogFile ):
    if LogFile!=False:
        # Ausgaben in Datei mitloggen:
        sys.stdout = RedirectStdOut( LogFile, sys.stdout )
        sys.stderr = RedirectStdOut( LogFile, sys.stderr )

    print "="*80

    # Umgebungsvariablen setzten, die man in CGI-Skripten abfragen kann und normalerweise
    # von einem echten WebServer automatisch gesetzt werden
    os.environ['DOCUMENT_ROOT']     = os.getcwd()

    # Liste aller Unetrverzeichnisse erzeugen, damit überall CGIs ausgeführt werden.
    print "Lese Verzeichnisbaum für CGI-Ausführung...",
    cgi_directories = [os.path.normpath( os.sep + i[0] ) for i in os.walk(cgiVerz)]
    print "OK",len(cgi_directories),"Verz. gefunden\n"
    #~ for i in cgi_directories: print i

    print "ROOT-Pfad .......................:", os.getcwd()
    if LogFile!=False:
        print "Log-Datei .......................:", os.path.join( os.getcwd(), LogFile )
    print "Starte CGI-HTTP-Server auf Port .:", ListenPort
    print "Zugelassener IP-Bereich .........:", AllowIPs
    print
    print "Seiten sind nun unter [http://localhost:%s] erreichbar!\n" % ListenPort

    # Variablen in MyRequestHandler setzten:
    MyRequestHandler.cgi_directories    = cgi_directories

    httpd = MyThreadingServer( ("", ListenPort), MyRequestHandler, AllowIPs )

    print "*** Server gestartet ***"

    httpd.serve_forever()




if __name__=="__main__":
    cgiVerz = "." # CGI's in jedem Pfad erlauben
    ListenPort = 9000
    AllowIPs = ('127.0.0.1', '192.168.*.*')
    #~ LogFile = "logs\\LogFile.txt"
    LogFile = False # Keine Log erstellen

    ServerStart( cgiVerz, ListenPort, AllowIPs, LogFile )

[jens]

Hab nun ein paar Tests mit dem Server gemacht...
Etwas komisch reagiert das ganze, wenn ich in meinen CGI-Skripten änderungen vornehme... Anscheinend wirkt sowas wie ein Cache... Denn die Änderungen werden teilweise erst dann sichtbar, wenn ich den Python-CGIserver beende und wieder neu starte?!?!?

Im Browser hab ich den Cache extra geleert...

EDIT: Ah, ich glaube das ist mein altes Problem: http://www.python-forum.de/viewtopic.php?t=2937 Der Threading-Server ist wohl nicht wirklich einsatzbereit

[jens]

Also an der Threading-Server Variante scheind es wohl doch nicht zu liegen... Änderungen in den CGI-Sourcen werden auch mit dem BaseHTTPServer.HTTPServer erst wirksam, wenn ich den Server neu starte...

An welchem Hebel kann ich ansetzten, damit es richtig Funktioniert???

[jens]

Das Problem ist auf execfile() zurück zu führen und wohl ehr von allgemeiner Natur, deswegen hab ich es nochmal hierhin "verschoben": http://www.python-forum.de/viewtopic.php?t=3994

[jens]

OK, da das exefile()-Problem wohl erstmal nur umgangen werden kann, wenn subprocess genommen wird, hier eine neue Version:

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: ISO-8859-1 -*-

__version__ = "0.0.6"

__history__ = """
v0.0.6
    - Überschreiben der CGIHTTPServer.execfile() damit Skripte nicht per
        execfile() sondern per subprocess ausgeführt werden. Damit alle
        "Sub"-Module immer neu geladen werden.
v0.0.5
    - os.environ["QUERY_STRING"] wird richtig übergeben
"""

import CGIHTTPServer, SocketServer
import os, sys, socket, webbrowser, subprocess



class execscript:
    def __call__( self, scriptfile, dummy ):
        p = subprocess.Popen(
                "%s %s" % ( sys.executable, scriptfile ),
                cwd     = ".",
                shell   = True,
                stdin   = subprocess.PIPE,
                stdout  = subprocess.PIPE,
                stderr  = subprocess.PIPE
            )
        p.stdin = sys.stdin

        sys.stdout.write( p.stdout.read() )
        sys.stderr.write( p.stderr.read() )

# Überschreiben der execscript() Funktion, mit der subprocess-Variante ;)
CGIHTTPServer.execfile = execscript()



class MyRequestHandler( CGIHTTPServer.CGIHTTPRequestHandler ):
    "Modifizieren des Standart RequestHandlers"

    # Damit auch unter Linux, welches fork unterstützt, das Python-CGI-Skript
    # unter dem User ausgeführt wird, mit dem der CGIHTTPServer gestartet wurde
    # und nicht mit User nobody...
    have_fork = False
    have_popen2 = False
    have_popen3 = False


    def is_cgi(self):
        "Modifikation, sodas man im CGI-Verzeichnis ein Dir-Listing bekommt"
        if "?" in self.path:
            script_file, query_string = self.path.split("?",1)
            query_string = "?" + query_string
        else:
            query_string = ""
            script_file = self.path

        script_base, script_filename = os.path.split( script_file )
        if script_filename=="":
            return False

        if os.path.splitext( script_filename )[1] != ".py":
            return False

        script_base = os.path.normpath( script_base )

        # Wird für self.run_cgi() benötigt
        self.cgi_info = script_base, script_filename + query_string

        os.environ['DOCUMENT_ROOT']     = os.getcwd()
        os.environ["SCRIPT_FILENAME"]   = script_filename

        return True # Ist ein "CGI"


class MyThreadingServer( SocketServer.ThreadingTCPServer ):
    """
    Verbesserung des Standart Servers:
     - ermöglicht das abarbeiten mehrere Anfragen parallel (z.B. Download mehrere Dateien gleichzeitig)
     - Ermöglicht das einschränken des IP-Bereiches aus denen der Server Anfragen behandelt
    """
    allow_reuse_address = 1    # Seems to make sense in testing environment


    def __init__(self, server_address, request_handler, AllowIPs):
        SocketServer.ThreadingTCPServer.__init__(self, server_address, request_handler)
        self.AllowIPs = [mask.split('.') for mask in AllowIPs]

    def server_bind(self):
        """Override server_bind to store the server name. (Parallele Anfragen)"""
        SocketServer.ThreadingTCPServer.server_bind(self)
        host, port = self.socket.getsockname()[:2]
        self.server_name = socket.getfqdn(host)
        self.server_port = port

    def verify_request(self, dummy, client_address):
        """Checkt ob die IP-Adresse der Anfrage in 'AllowIPs' vorhanden ist"""
        def check_ip(mask):
            for mask_part, ip_part in zip(mask, ip):
                if mask_part != ip_part and mask_part != '*':
                    return False
            return True

        ip = client_address[0].split('.')

        for mask in self.AllowIPs:
            if check_ip(mask):
                return True

        print "IP [%s] not allowed!" % client_address

        return False




def ServerStart( cgiVerz, ListenPort, AllowIPs ):
    print "="*80
    print "ROOT-Pfad .......................:", os.getcwd()
    print "Starte CGI-HTTP-Server auf Port .:", ListenPort
    print "Zugelassener IP-Bereich .........:", AllowIPs
    print
    print "Seiten sind nun unter [http://localhost:%s] erreichbar!\n" % ListenPort

    httpd = MyThreadingServer( ("", ListenPort), MyRequestHandler, AllowIPs )

    # Öffne Browser
    webbrowser.open_new("http://localhost/index.py")

    httpd.serve_forever()




if __name__=="__main__":
    cgiVerz = "." # CGI's in jedem Pfad erlauben
    ListenPort = 80
    AllowIPs = ('127.0.0.1', '192.168.*.*')

    ServerStart( cgiVerz, ListenPort, AllowIPs )

Dabei gibt es allerdings wieder mal ein anderes Problem, wofür ich eure hilfe brauche!
Und zwar, werden anscheinend keine POST-Formulare korrekt an's CGI geschickt.
Genauer gesagt, liefert cgi.FieldStorage() keine Werte. Aus den cgi.py Sourcen kann man entnehmen, das cgi.FieldStorage() die Daten per stdin liest (Zeile 629). In CGIHTTPServer.py Zeile 294 wird anscheinen stdin irgendwie gefüttert.

Offensichtlich klappt die übertragung der Daten per subprocess nicht richtig...

Kann mir jemand helfen???

[jens]

Eine andere Variante mit p.stdin.write( sys.stdin.read() ) funktioniert leider auch nicht, da die Ausführung blockiert wird

Ob überhaupt die POST Daten per stdin Übertragen werden?

[jens]

Dank newsgroups und Mailliste habe ich eine Lösung meines eigens geschaffenen Problems gefunden...

Und zwar ist es so, das ich den Server vorher in einem anderen Projekt benutzt hab. Da war es wichtig, das CGI-Skripte mit dem User ausgeführt werden, mit dem der Server gestartet ist.
Das ist unter Linux nicht so, da Linux fork bzw. os.setuid() unterstützt. In dem Fall werden Skripte als User nobody ausgeführt. Das kann man in CGIHTTPServer.py in Zeile 204 bzw. 225 sehen.
Deswegen hatte ich im RequestHandler meines Servers diese drei Zeilen drin:

Code: Alles auswählen

    have_fork = False
    have_popen2 = False
    have_popen3 = False

Das bedeutet aber auch, das die Skripte immer mit execfile() aufgeführt werden, was eigentlich nur eine Notlösung ist.

Lange Rede kurzer Sinn... Durch das löschen der drei have_*-Zeilen, hat sich mein Problem in Luft aufgelöst.

Sorry, war mein Fehler...

Also hier der Server, der nun richtig klappt:

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: ISO-8859-1 -*-

__version__ = "0.0.7"

__history__ = """
v0.0.7
    - subprocess unnötig, da have_fork, have_popen2 und have_popen3 unnötigerweise
        auf False im RequestHandler gesetzt wurden. Das bedeutetet das die CGI
        Skripte immer mit der Notlösung execfile() ausgeführt wurden.
v0.0.6
    - Überschreiben der CGIHTTPServer.execfile() damit Skripte nicht per
        execfile() sondern per subprocess ausgeführt werden. Damit alle
        "Sub"-Module immer neu geladen werden.
v0.0.5
    - os.environ["QUERY_STRING"] wird richtig übergeben
"""

import CGIHTTPServer, SocketServer
import BaseHTTPServer
import os, sys, socket, webbrowser


class MyRequestHandler( CGIHTTPServer.CGIHTTPRequestHandler ):
    """Modifizieren des Standart RequestHandlers"""

    def is_cgi(self):
        """
        Einfachere Variante, sodas alle Python-Skripte überall ausgeführt werden#
        """
        base, filename = os.path.split( self.path )

        if ".py" in filename:
            if "?" in filename:
                os.environ["SCRIPT_FILENAME"] = filename.split("?",1)[0]
            else:
                os.environ["SCRIPT_FILENAME"] = filename

            os.environ['DOCUMENT_ROOT']     = os.getcwd()
            self.cgi_info = base, filename
            return True

class MyThreadingServer( SocketServer.ThreadingTCPServer ):
    """
    Verbesserung des Standart Servers:
     - ermöglicht das abarbeiten mehrere Anfragen parallel (z.B. Download mehrere Dateien gleichzeitig)
     - Ermöglicht das einschränken des IP-Bereiches aus denen der Server Anfragen behandelt
    """
    allow_reuse_address = 1    # Seems to make sense in testing environment


    def __init__(self, server_address, request_handler, AllowIPs):
        SocketServer.ThreadingTCPServer.__init__(self, server_address, request_handler)
        self.AllowIPs = [mask.split('.') for mask in AllowIPs]

    def server_bind(self):
        """Override server_bind to store the server name. (Parallele Anfragen)"""
        SocketServer.ThreadingTCPServer.server_bind(self)
        host, self.server_port = self.socket.getsockname()[:2]
        self.server_name = socket.getfqdn(host)

    def verify_request(self, dummy, client_address):
        """Checkt ob die IP-Adresse der Anfrage in 'AllowIPs' vorhanden ist"""
        def check_ip(mask):
            for mask_part, ip_part in zip(mask, ip):
                if mask_part != ip_part and mask_part != '*':
                    return False
            return True

        ip = client_address[0].split('.')

        for mask in self.AllowIPs:
            if check_ip(mask):
                return True

        print "IP [%s] not allowed!" % client_address

        return False




def ServerStart( ListenPort, AllowIPs ):
    print "="*80
    print "ROOT-Pfad .......................:", os.getcwd()
    print "Starte CGI-HTTP-Server auf Port .:", ListenPort
    print "Zugelassener IP-Bereich .........:", AllowIPs
    print
    print "Seiten sind nun unter [http://localhost:%s] erreichbar!\n" % ListenPort

    httpd = MyThreadingServer( ("", ListenPort), MyRequestHandler, AllowIPs )

    # Öffne Browser
    webbrowser.open_new("http://localhost/index.py")

    httpd.serve_forever()


if __name__=="__main__":
    ServerStart(
        ListenPort  = 80,
        AllowIPs    = ('127.0.0.1', '192.168.*.*')
    )

[Ubuntuuser]

Hallo,
ich weiß dieser thread ist schon etwas älter,da ich aber den von Jens eröffneten thread mit dem Server so interessant fand habe ich mir gedacht ein automatisiertes kleines tool zu schreiben um den Server komfortabler zu starten..ob das jetzt sinnvoll ist oder nicht.Das tool MiniServer startet den Server und den Browser gleichzeitig.Naja nichts aussergewöhnliches...doch ich habe mal die Server.py datei in eine Py2Exe,also in eine ausführbare Datei erstellt.Beim testen wollte ich wissen ob es möglich ist auch den Server zu starten ohne Python auf dem System installiert zu haben-siehe da es hat geklappt.Der einzige nachteil dabei ist das *py Dateien dann nicht geöffnet werden können,dazu braucht man Python und Python muss installiert sein-klaro.Ich bin dabei so vorgegangen das ich nicht Python deinstalliert habe sondern einfach den Ordner Python24 unbenannt habe.

Ok,sofern ist das tool praktisch weil auch User die nicht Python nützen und kein Python installiert haben aber einen Server haben möchten der HTML,Text oder Bilder anzeigt oder einfach ihr webprojekt damit öffnen wollen ,einen Server starten können.

Jetzt würden mich mal Meinungen interessieren-Sinnvolles Tool oder unbrauchbar-Kritik,Meinungen,Vorschläge,Verbesserungen,Ideen sind erwünscht...achso danke noch an Jens der ja diesen thread vor längerer Zeit eröffnet hat und diesen kleinen Server geschrieben hat.

hier mal ein Screenshot

und hier das Tool MiniServer
download>>Miniserver_win32
Dateigrösse:2,9 mb


das tool ist eine setup-datei mit uninstaller also einfach installieren,es wird danach gleich gestartet und hat ein paar Beispiele HTML.

Grüsse Ubuntuuser

P.S. Ich weiss,ich weiss... der name Ubuntuuser und dann eine win32 Anwendung geschrieben-das tool ist nur für Windows...das passt nicht.Deswegen nütze ich trotzdem weiterhin Ubuntu.Na und....

[Leonidas]

Jetzt würden mich mal Meinungen interessieren-Sinnvolles Tool oder unbrauchbar-Kritik,Meinungen,Vorschläge,Verbesserungen,Ideen sind erwünscht...achso danke noch an Jens der ja diesen thread vor längerer Zeit eröffnet hat und diesen kleinen Server geschrieben hat.

Ganz ehrlich? Ich finds sinnlos. Es startet einen Server und hat zwei Knöpfe. Wofür braucht man einen Webserver mit GUI? Unter Windows startet der Apache 1.3.x auch in einem Konsolen-Fenster und zum beenden macht man das Fenster einfach zu.
Persönlich mag ich es auch nicht, wenn ein App mir auch ungefragt irgendwelche Programme aufamacht, wie Browser, E-Mailprogramm etc.

Als Programmierübung nett, aber darin sehe ich keinen praktischen Sinn.

[Y0Gi]

Um CGI-Scripts lokal zu testen würde ich meinem aktuellen Kenntnisstand nach den CGI-Wrapper von Paste über `paster serve` verwenden, wobei der verwendete Mini-Server letztlich auf dem HTTP-Server aus der Stdlib von Python basiert. Und über Middlewares wie debug.prints, debug.cgitb_catcher oder diese interaktive Konsole (Name entfallen, bisher noch nicht benutzt) lässt sich dann schön debuggen oder verifizieren.