Keyserver - Dateienaustausch und Abruf

[gerold]

Kann ich dem Client jetzt sagen, dass er das in eine Datei schreiben soll ?! am besten noch mit dem gleichen dateinamen

Hi dankegut!

Natürlich geht das. Du musst dich nur darum kümmern, dass sich der Inhalt der zu übertragenden Datei nicht beim Übertragen ändert. -- Also keine Windows-Zeilenumbrüche in Linux-Zeilenumbrüche umgewandelt werden. Oder auch dass Sonderzeichen korrekt übertragen werden. Dafür gibt es in der ``xmlrpclib`` den Datentyp ``Binary``.

server.py:

Code: Alles auswählen

#!/usr/bin/env python -O
# -*- coding: utf-8 -*-
"""
******************************************************************************
* Simple XMLRPC-Server
******************************************************************************
"""

import xmlrpclib
from SimpleXMLRPCServer import SimpleXMLRPCServer

KEYFILE = "my_key.xml"


class XmlrpcHandler:
    
    def get_keyfile(self):
        """
        Gibt den Inhalt und den Dateinamen der Datei KEYFILE zurück.
        """
        
        f = file(KEYFILE, "rb")
        ret_dict = {
            "filename": KEYFILE,
            "content": xmlrpclib.Binary(f.read())
        }
        f.close()
        return ret_dict


def main():
    """
    Hauptprozedur
    """
    
    server = SimpleXMLRPCServer(("localhost", 50505))
    server.register_instance(XmlrpcHandler())
    print "Der XMLRPC-Server horcht auf http://localhost:50505."
    print "Er kann mit STRG+C oder STRG+PAUSE beendet werden."
    server.serve_forever()


if __name__ == "__main__":
    main()

client.py:

Code: Alles auswählen

#!/usr/bin/env python -O
# -*- coding: utf-8 -*-
"""
******************************************************************************
* Einfacher XMLRPC-Client
******************************************************************************
"""

import xmlrpclib


def main():
    """
    Hauptprozedur
    """
    
    server = xmlrpclib.ServerProxy("http://localhost:50505")
    ret_dict = server.get_keyfile()
    
    print "Filename:", ret_dict["filename"]
    print "Content:", ret_dict["content"].data


if __name__ == "__main__":
    main()

mfg
Gerold


Stichworte: binär daten übertragen binary data

[gerold]

PS: Gespeichert wird so:

Code: Alles auswählen

    f_out = file("new_" + ret_dict["filename"], "wb")
    f_out.write(ret_dict["content"].data)
    f_out.close()

mfg
Gerold

[Masaru]

Warum soll man etwas komplizierteres dafür verwenden?

Hi gerold, habe ich gesagt, man soll etwas kompliziertes verwenden? Wenn ja, dann nehme ich es zurück . Kompliziertes "sollte" man natürlich nicht verwenden *g* ... gibt ja zum Glück auch einfacheres.

[gerold]

Kompliziertes "sollte" man natürlich nicht verwenden *g* ... gibt ja zum Glück auch einfacheres.

Hi Masaru!

Ab und zu kann ich mich nicht so ausdrücken, wie ich es eigentlich meine. Ich wollte da jetzt niemanden runter machen. Sorry!

Natürlich stimme ich dir zu, dass man für den reinen Dateiaustausch nicht XMLRPC verwenden soll. Dafür ist FTP und Co. viel besser geeignet. Bei XMLRPC wird immer die komplette Datei in den Speicher geladen, bevor diese verschickt wird. Auch beim Client muss zuerst die Datei in den Speicher geladen werden, bevor diese gespeichert werden kann. XMLRPC ist schon deshalb nicht für den Dateiaustausch geeignet.

XMLRPC ist besser geeignet, wenn man z.B. auf Datenbanken zugreifen möchte, da beim Aufruf vom Client aus, eine Funktion beim Server ausgeführt wird.

Wenn der OP wirklich nur XML-Dateien austauschen und hochladen möchte, dann sollte er sich sofort nach einer anderen Möglichkeit umsehen. (z.B. FTP)

@dankegut:

Falls du alles in eine XML-Datei schreiben möchtest und wirklich mit 30 gleichzeitigen Prozessen rechnest, dann ist XML dafür komplett ungeeignet.
Eine XML-Datei muss bei jeder Änderung komplett neu geschrieben werden und das kann immer nur ein Prozess/Thread. Die anderen Threads können die Datei nicht öffnen oder überschreiben (je nach Betriebssystem) Änderungen, die von anderen Threads gemacht wurden.
Du könntest mit Queue-Objekten (siehe: http://www.python-forum.de/post-32524.html#32524) oder Lock-Dateien arbeiten um immer nur eine Änderung nach der Anderen in der XML-Datei durchzuführen, aber dann bleibt immer noch das Problem, dass die XML-Datei jedes mal komplett neu geschrieben werden muss.

Wenn du mit vielen kleinen XML-Dateien arbeitest, dann bleibt immer noch die Frage, ob du die Arbeit nicht auch von einem reinen FTP-Server erledigen lassen kannst.

Vielleicht erklärst du noch einmal, was du genau machen möchtest. Vielleicht gibt es eine bessere Möglichkeit...

mfg
Gerold

[dankegut]

Hallo,

erstmal danke für die vielen Antworten. Also nach unserem letzten Projektmeeting ging es genau um diese Frage, da DOM einfach viel zu viel Ressourcen verbraucht um die Daten zu schreiben, ändern etc. Daher spiele ich mit dem Gedanken eine Datenbank zu benutzen, dann wäre es ja sinnvoll beim xml-rpc zu bleiben, denn bis jetzt gefällt es mir sehr gut. Es geht bei diesem Projekt auf jedenfall nicht um reinen Datenaustausch.
Da wir aber noch ein paar andere Dinge implementieren wollen, muss ich das ganze nochmal abwägen. Ich hab jetzt einige verschiedene Szenarien programmiert, sei es mit twisted, xmlrpclib, sockets, etc. ... alles weitere wird sich zeigen.

[gerold]

Hallo Gerold,
danke für die vielen kleinen snippets, damit kann ich mir sehr gut weiteres ableiten, leider stoße ich jetzt an ein Problem, das ich nicht hinkriege, oder ich mir denke, dass es vllt gar nicht möglich ist.. und zwar den dateienaustauschvom client zum server, nur per rpc wird das schlecht gehen oder?! der client soll zusagen was zum server schicken und dieser es vorerst einfach mal ausgeben, zum speichern komm ich später
hast du da vielleicht ne idee?

Hi dankegut!

Es gibt keinen Grund, solche Fragen als PN zu stellen. Das könnte andere ja auch interessieren.

Es ist kein Problem, vom Client Daten zum Server zu übertragen.

server.py:

Code: Alles auswählen

#!/usr/bin/env python -O
# -*- coding: utf-8 -*-
"""
Server
"""

import xmlrpclib
from SimpleXMLRPCServer import SimpleXMLRPCServer


class XmlrpcHandler:
   
    def print_key(self, binary_key):
        
        if isinstance(binary_key, xmlrpclib.Binary):
            print binary_key.data
        else:
            print binary_key
        
        return "OK"


def main():
    server = SimpleXMLRPCServer(("localhost", 50505))
    server.register_instance(XmlrpcHandler())
    print "Der XMLRPC-Server horcht auf http://localhost:50505."
    print "Er kann mit STRG+C oder STRG+PAUSE beendet werden."
    server.serve_forever()


if __name__ == "__main__":
    main()

client.py:

Code: Alles auswählen

#!/usr/bin/env python -O
# -*- coding: utf-8 -*-
"""
Client
"""

import xmlrpclib


def main():
    """
    Hauptprozedur
    """
   
    server = xmlrpclib.ServerProxy("http://localhost:50505")
    
    s = """
    Das ist die perfekte Welle.
    Das ist der perfekte Tag.
    """
    binary_key = xmlrpclib.Binary(s)
    print server.print_key(binary_key)


if __name__ == "__main__":
    main()

mfg
Gerold

[dankegut]

so, bei mir liegt mal wieder ein problem an. Ich hab hier schon einiges im Board über Listen und Dictionarys gefunden, und zwar geht es um die abspeicherung der Daten beim Server. Das mit der DB hab ich erstmal hinten angestellt, da ich denke, dass ein indiziertes Dictionary sinnvoller wäre, in Kombination mit einer Liste, vielleicht sogar nur eine Liste, so ungefähr:

Code: Alles auswählen

class keys:
    def __init__(self, algo, key, name, hash):
        self.algo = algo
        self.key = key
        self.name = name
        self.hash = hash

keylist = []
keylist.append(keys("rsa", "23999234999239999932x0", "chris", "232343332"))
keylist.append(keys("el-gamal", "234234x0", "martin", "234234"))

for k in keylist:
    print k.algo
    print k.key
    print k.name
    print k.hash

aber ob das sinnvoll ist?! Beim Löschen muss ja(wenn ich richtig informiert bin) das gleiche aufgerufen werden, wie mit append, halt nur mit remove. Desweiteren sehe ich noch Probleme bei einer SuchenOption

Habt ihr da vielleicht irgendwelche vorschläge?

Danke und Gruss

Christian

[Leonidas]

aber ob das sinnvoll ist?! Beim Löschen muss ja(wenn ich richtig informiert bin) das gleiche aufgerufen werden, wie mit append, halt nur mit remove. Desweiteren sehe ich noch Probleme bei einer SuchenOption

Also bis auf etwaige Performance-Probleme mit sehr großen Listen sehe ich da eigentlich keine größeren einwände. Einen Key löscht du, indem du seinen Index bestimmst und ihn dann mit .pop(index) entfernst. Suchen wird auf die gleiche weise implementiert: du gehtst alle Elemente der Liste durch (das ist eben das angesprochene Performance-Problem), bis du einen passenden Key gefunden hast und gibst dann diesen aus.

[gerold]

Desweiteren sehe ich noch Probleme bei einer SuchenOption. Habt ihr da vielleicht irgendwelche vorschläge?

Hi Christian!

Wenn du **ein** Feld hast, nach dem gesucht werden soll und du meistens nur nach diesem einen Feld suchst (z.B. ``key``), dann gibt es kaum etwas schnelleres als ein Dictionary. Aber ein Dictionary ist immer im Speicher. Du brauchst etwas, was die Daten im Dateisystem hält. In diesem Fall gibt es kaum etwas schnelleres als **Shelve**. Shelve ist wie ein Dictionary im Datesystem. Es ist wirklich sauschnell. Mehrere Millionen Datensätze ist kein wirkliches Problem für Shelve.

Wenn du aber z.B. nach allen Schlüsseln suchst, die als "algo" "rsa" drinnen stehen haben, dann müssen alle Schlüssel durchsucht werden -- wie bei einer Liste auch. Wenn du aber nach dem Key suchst, dann ist das Ding blitzschnell.

Beispiel:

Code: Alles auswählen

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

import shelve, pickle

FILENAME = "keyfile.shelve"


class Key(object):
    """
    Ein Schlüssel
    """
   
    __slots__ = ("algo", "key", "name", "hashval")
   
    def __init__(self, algo, key, name, hashval):
        """
        Initialisiert den Schlüssel mit den übergebenen Daten.
        """
       
        self.algo = algo
        self.key = key
        self.name = name
        self.hashval = hashval


class KeyDepot(object):
    """
    Schlüsselkontainer
    """
   
    def __init__(self, filename):
        """
        Öffnet das Shelve-File
        """
       
        self._shelve = shelve.open(filename, protocol = pickle.HIGHEST_PROTOCOL)
   
   
    def set_key(self, algo, key, name, hashval):
        """
        Setzt den Schlüssel (key) mit den übergebenen Werten.
        """
       
        self._shelve[str(key)] = Key(algo, key, name, hashval)
   
   
    def get_key(self, key):
        """
        Gibt den Schlüssel mit dem Key (key) zurück.
        """
       
        return self._shelve[str(key)]
   
   
    def iterkeys(self):
        """
        Gibt einen Iterator mit den Schlüsseln des Shelve-Objekts zurück.
        """
       
        return self._shelve.iterkeys()
   
   
    def itervalues(self):
        """
        Gibt einen Iterator mit den einzelnen Key-Objekten zurück.
        """
       
        return self._shelve.itervalues()
   
   
    def iteritems(self):
        """
        Gibt einen Iterator mit den Shelve-Schlüsseln und den Key-Objekten zurück.
        """
       
        return self._shelve.iteritems()
   
   
    def __del__(self):
        """
        Destruktor; Schließt das Shelve-Objekt.
        """
       
        self._shelve.close()


def main():
   
    keys = KeyDepot(FILENAME)
   
    print "Keys hinzufuegen:"
    keys.set_key("rsa", "23999234999239999932x0", "chris", "232343332")
    keys.set_key("el-gamal", "234234x0", "martin", "234234")
   
    print
    print "Einen Key abrufen:"
    key = keys.get_key("234234x0")
    print key.algo, key.key, key.name, key.hashval
   
    print
    print "Alle Keys:"
    for key in keys.itervalues():
        print key.algo, key.key, key.name, key.hashval
   
    print
    print "Alle RSA-Keys:"
    for key in keys.itervalues():
        if key.algo == "rsa":
            print key.algo, key.key, key.name, key.hashval
   

if __name__ == "__main__":
    main()

Wenn du mehr Flexibilität brauchst, dann kommst du um eine Datenbank nicht herum. Wenn es nur etwas Kleines sein soll, worauf immer nur ein Prozess schreibend zugreift, dann **pySQLite** (SQLite). Wenn mehrere Prozesse/Threads gleichzeitig lesend und schreibend darauf zugreifen sollen, dann bist du mit **psycopg2** (PostgreSQL) gut bedient.

Für ein paar zehntausend Keys, rentiert es sich kaum, eine große Datenbank einzurichten. Dafür ist SQLite leicht genug.

Wird meistens nach dem "Key" gesucht, dann gibt es wohl kaum etwas schnelleres als Shelve.

mfg
Gerold


Edit: Ich hatte die Funktion ``hash`` überschrieben. Das kann zu unerwarteten Ergebnissen führen. ``hash`` wurde nach ``hashval`` ausgebessert.

[gerold]

...

Die Datenbankversion ist ein wenig komplizierter. Dafür aber auch flexibler.

Code: Alles auswählen

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

try:
    # Ab Python 2.5
    import sqlite3
except ImportError:
    # Vor Python 2.5 --> pysqlite --> http://initd.org/tracker/pysqlite
    from pysqlite2 import dbapi2 as sqlite3 

FILENAME = "keyfile.s3db"


class Key(object):
    """
    Ein Schlüssel
    """
   
    __slots__ = ("algo", "key", "name", "hashval")
   
    def __init__(self, algo, key, name, hashval):
        """
        Initialisiert den Schlüssel mit den übergebenen Daten.
        """
       
        self.algo = algo
        self.key = key
        self.name = name
        self.hashval = hashval


class KeyDepot(object):
    """
    Schlüsselkontainer
    """
   
    def __init__(self, filename):
        """
        Öffnet die Verbindung zur Datenbank
        """
        
        conn = sqlite3.connect(filename)
        self.conn = conn
        
        cur = conn.cursor()
        self.cur = cur
        
        self.create_dbstructure()
    
    
    def create_dbstructure(self):
        """
        Erstellt die Tabellen
        """
        
        cur = self.cur
        conn = self.conn
        
        # keys-Tabelle erstellen, falls noch nicht erstellt.
        sql = """
        SELECT name FROM sqlite_master 
        WHERE (type = 'table') AND (name = 'keys')
        """
        cur.execute(sql)
        if not self.cur.fetchone():
            # Die Tabelle existiert noch nicht. Sie kann erstellt werden.
            sql = """
            CREATE TABLE keys (
              key TEXT PRIMARY KEY NOT NULL,
              algo TEXT,
              name TEXT,
              hashval TEXT
            )
            """
            cur.execute(sql)
        
        # Index(e) erstellen
        sql = """
        SELECT name FROM sqlite_master 
        WHERE (type = 'index') AND (name = 'i_keys_algo')
        """
        cur.execute(sql)
        if not cur.fetchone():
            sql = "CREATE INDEX i_keys_algo ON keys (algo)"
            cur.execute(sql)
        
        conn.commit()

    
    def set_key(self, algo, key, name, hashval):
        """
        Schreibt den übergebenen Schlüssel (key) in die DB
        """
        
        conn = self.conn
        cur = self.cur
       
        sql = """
        SELECT key FROM keys WHERE (key = :key)
        """
        cur.execute(sql, locals())
        if self.cur.fetchone():
            # Update
            sql = """
            UPDATE
              keys
            SET
              algo = :algo,
              name = :name,
              hashval = :hashval
            WHERE
              (key = :key)
            """
        else:
            # Insert
            sql = """
            INSERT INTO keys (
              key, algo, name, hashval
            ) VALUES (
              :key, :algo, :name, :hashval
            )
            """
        cur.execute(sql, locals())
        conn.commit()
    
    
    def get_key(self, key):
        """
        Gibt den angeforderten Schlüssel zurück
        """
        
        cur = self.cur
        
        sql = """
        SELECT
          algo, name, hashval
        FROM
          keys
        WHERE
          (key = :key)
        """
        cur.execute(sql, locals())
        row = cur.fetchone()
        
        algo = row[0]
        name = row[1]
        hashval = row[2]
        
        return Key(algo, key, name, hashval)


    def get_all_keys(self):
        """
        Gibt alle Schlüssel in einer Liste zurück.
        """
        
        cur = self.cur
        
        sql = """
        SELECT
          key, algo, name, hashval
        FROM
          keys
        """
        cur.execute(sql)
        
        retlist = []
        for row in cur:
            key = row[0]
            algo = row[1]
            name = row[2]
            hashval = row[3]
            retlist.append(Key(algo, key, name, hashval))
        
        return retlist


    def get_filtered_keys(self, algo = None):
        """
        Gibt die (im Beispiel nach 'algo') gefilterte Schlüsselliste zurück.
        """
        
        cur = self.cur
        
        sql = """
        SELECT
          key, algo, name, hashval
        FROM
          keys
        """
        if algo:
            sql += """
            WHERE
              (algo = :algo)
            """
        cur.execute(sql, locals())
        
        retlist = []
        for row in cur:
            key = row[0]
            algo = row[1]
            name = row[2]
            hashval = row[3]
            retlist.append(Key(algo, key, name, hashval))
        
        return retlist


def main():
   
    keys = KeyDepot(FILENAME)
   
    print "Keys hinzufuegen:"
    keys.set_key("rsa", "23999234999239999932x0", "chris", "232343332")
    keys.set_key("el-gamal", "234234x0", "martin", "234234")
   
    print
    print "Einen Key abrufen:"
    key = keys.get_key("234234x0")
    print key.algo, key.key, key.name, key.hashval
   
    print
    print "Alle Keys:"
    for key in keys.get_all_keys():
        print key.algo, key.key, key.name, key.hashval
   
    print
    print "Alle RSA-Keys:"
    for key in keys.get_filtered_keys(algo = "rsa"):
        print key.algo, key.key, key.name, key.hashval
   

if __name__ == "__main__":
    main()

mfg
Gerold


Edit: Ich hatte die Funktion ``hash`` überschrieben. Das kann zu unerwarteten Ergebnissen führen. ``hash`` wurde nach ``hashval`` ausgebessert.

[gerold]

...Vorsicht!

Ich hatte in den Beispielen die Funktion ``hash`` überschrieben. Das kann zu unerwarteten Ergebnissen führen. ``hash`` wurde nach ``hashval`` ausgebessert.

lg
Gerold

[dankegut]

wow, ich bin überwältigt. shelve hatte ich mir vorher gar nicht so genau angeschaut, aber ich denke, dass ich damit arbeiten werde. danke für deinen mühen, ist ja nicht gerade wenig code, den du da gepostet hast.

[dankegut]

hallo,

also ich habe jetzt soweit shelve mit eingebunden, und n bisschen mit rumgespielt. Problem: ich kann aufm server ohne probleme drauf zugreifen, set_keys, itervalues geht, ... sobald ich aber die methode itervalues vom Client aufrufe, gibt es ein

Exceptions.NameError:global name "keys" is not defined"

jemand eine Idee? Falls ich den Code noch posten soll, bitte melden

Danke

[dankegut]

hmm.. also den oberen fehler hab ich beseitigt, jetzt aber dies hier:

exceptions.TypeError: cannot marshal None unless allow_none is enabled

Client

Code: Alles auswählen

server.saveKey("rsa", "bla", "blub" "chris" "localhost")

server.listAllKeys funktioniert übrigens, nur das abspeichern nicht

Server

Code: Alles auswählen

class KeyDepot(object):
    def set_key(self, algo, key, hashval, name, host)
        self._shelve[str(key) = Key(algo, key, hashval, name, host)

class XMLRPCHandler:
    def listAllKeys(self):
        for key in keys.itervalues():
            return key.algo, key.key, key.hashval, key.name, key.host
   
    def saveKey(self, algo, key, hashval, name, host):
        keys.set_key(algo, key, hashval, name, host)

def main():
    # testdaten
     keys.set_key("rsa", "w32", "999", "chris", "local")

if __name__=="__main__":
     keys = KeyDepot(FILENAME)
     main()

Hab natürlich beides sehr abgespeckt, aber man sollte daraus erkennen wo es hängt. Muss ich die Daten vom Client anders an den Server übergeben?

Danke und Gruß
Christian

[gerold]

Code: Alles auswählen

class KeyDepot(object):
    def set_key(self, algo, key, hashval, name, host)
        self._shelve[str(key) = Key(algo, key, hashval, name, host)

Hi Christian!

Also diese Zeile ist garantiert falsch:

Code: Alles auswählen

        self._shelve[str(key) = Key(algo, key, hashval, name, host)

Außerdem ist es nicht einfach, ohne den exakten Traceback (und damit meine ich nicht nur eine Zeile davon), eine Diagnose zu stellen.
Im Traceback steht in welcher Zeile, welche vorherigen Aufrufe stattfanden usw.

Fakt ist, dass Shelve kein None speichern will. Also musst du prüfen, was an Shelve übergeben wird. Offensichtlich wird nicht das an Shelve übergeben, was du erwartest, übergeben zu haben. Vielleicht hängt es schon daran, dass Werte falsch übergeben wurden... Erstelle zuerst die Klasseninstanz für den Key, schau dir an, was da drinnen steht und übergib diese Instanz dann an Shelve. So könntest du den Fehler entdecken.

mfg
Gerold

[dankegut]

hallo nochmal,

also bei vorherigen beispiel hab ich die daten ja mit in der methode übergeben und es hat nicht geklappt. Jetzt erstelle ich ein kleines dict im client so:

Code: Alles auswählen

key = {
               "algo":      "el-gamal",
               "key" :      "23234234234234323423423x0",
               "hashval":   "000111",
               "name":      "chris",
               "host":      "localhost"
        }
        server.sendKey(key)

in der server.py

Code: Alles auswählen

 def sendKey(self, key_dict):
        print key_dict.values()

steht nur das um die ausgabe zu überprüfen. Ich bekomme in der Console vom Server auch eine korrekte Ausgabe aber der Client bricht wie folgt danach ab:

Threads started
Exception in thread Thread-1:
Traceback (most recent call last):
File "threading.py", line 442, in __bootstrap
self.run()
File "client_xml.py", line 42, in run
print server.sendKey(key)
File "xmlrpclib.py", line 1096, in __call__
return self.__send(self.__name, args)
File "xmlrpclib.py", line 1383, in __request
verbose=self.__verbose
File "xmlrpclib.py", line 1147, in request
return self._parse_response(h.getfile(), sock)
File "xmlrpclib.py", line 1286, in _parse_response
return u.close()
File "xmlrpclib.py", line 744, in close
raise Fault(**self._stack[0])
Fault: <Fault 1: 'exceptions.TypeError:cannot marshal None unless allow_none is enabled'>

Fertig

Ich kriegs auch so irgendwie nicht gebacken, vorallem weil das shelve ja gar nicht angefasst wird. Geb ich das dict auf dem Server falsch aus?! Ich krieg den Fehler nicht behoben

Jemand eine Idee??

Gruß
Christian

[BlackJack]

Gib doch mal direkt nach dem versenden beim Client etwas mit ``print`` aus um zu sehen ob der Aufruf noch korrekt zurückkehrt.

[dankegut]

nein, hab direkt nach

server.sendKey(key)

eine print anweisung gemacht. Diese wird nicht mehr ausgegeben, also er bricht bei der sendKey Methode komplett ab :/

[dev]

in der server.py

Code: Alles auswählen

 def sendKey(self, key_dict):
        print key_dict.values()

schreib da einfach noch ein return 'OK' rein.

Der Traceback sagt Dir doch eigentlich schon, daß die xmlrpclib bei _parse_response, also dem Aufarbeiten der Antwort Deines serverseitigen calls das Problem hat 'Nichts' nur zurück an den Client senden zu können, wenn Du explizit allow_none = True setzt.

Gleiches gilt übrigens auch für einen call seitens des Clients ohne Parameter.

Ciao,
dev

[dankegut]

danke, das wars. Ich glaub da wär ich trotz des Tracebacks nicht so schnell drauf gekommen.

Gruß
Christian