Keyserver - Dateienaustausch und Abruf

Sockets, TCP/IP, (XML-)RPC und ähnliche Themen gehören in dieses Forum
dankegut
User
Beiträge: 29
Registriert: Montag 16. Oktober 2006, 18:56
Kontaktdaten:

Freitag 20. Oktober 2006, 18:28

hm, mein fehler. ich hatte da was mit den threads auskommentiert :oops:
da ging dann gar nix mehr :) ich habs jetzt einfach mal so gemacht:

Code: Alles auswählen

def listKeys(self):
        key = open("test.xml")
        return key.read()
nicht schön, aber naja. Kann ich dem Client jetzt sagen, dass er das in eine Datei schreiben soll ?! am besten noch mit dem gleichen dateinamen :roll:
BlackJack

Freitag 20. Oktober 2006, 21:07

Etwas sauberer wäre es, wenn Du die Datei auch selbst wieder schliesst. Und etwas flexibler wird's wenn Du den Dateinamen nicht hart kodierst sondern als Argument der Funktion übergibst.
Benutzeravatar
Masaru
User
Beiträge: 425
Registriert: Mittwoch 4. August 2004, 22:17

Samstag 21. Oktober 2006, 20:35

Allgemeine Info:
(vielleicht ganz interessant noch zu wissen)

XML-RPC "sollte" nie dazu dienen, ganze Dateninhalte zwischen zwei Punkten zu verschieben (Dateitransfer).

Wie der Name schon sagt, dreht es sich bei XML-RPC um Remote Procedure Calls, die mittels XML-Tags die Methodenaufrufe und Rückgaben verpacken.

RPC dient im allgemeinen dem üblen PC-Treiber dazu, "Funktionsaufrufe" auf entfernten Rechnern durchzuführen.

Funktionsaufrufe liefern zwar Ergebnisse im schlimmsten Falle zurück :wink:, jedoch nicht unbedingt Dateien.

Für einen "Dateitransfer" gibt es andere Protokolle, Spezifikationen, Implementierungen ... und RPC, sowie XML-RPC zählen eher eindeutig nicht dazu.
BlackJack

Samstag 21. Oktober 2006, 21:40

Naja der OP wollte Schlüssel austauschen, das kann man schon als Argument für einen entfernten Prozeduraufruf verstehen. Das die lokal und beim Empfänger irgendwie gespeichert werden müssen, ändert daran ja nichts.
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5555
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Oberhofen im Inntal (Tirol)
Kontaktdaten:

Samstag 21. Oktober 2006, 22:09

Masaru hat geschrieben:XML-RPC "sollte" nie dazu dienen, ganze Dateninhalte zwischen zwei Punkten zu verschieben (Dateitransfer).
Hi Masaru!

Warum soll man etwas komplizierteres dafür verwenden? Wenn ein Prozeduraufruf den Inhalt einer Datei zurück gibt, dann gibt er halt den Inhalt einer Datei zurück. Na und?

Nur aus Prinzip, weil es sich ja bei der Rückgabe um den Inhalt einer Datei handelt, halse ich mir nicht unbedingt etwas komplizierteres auf.

mfg
Gerold
:-)
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5555
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Oberhofen im Inntal (Tirol)
Kontaktdaten:

Samstag 21. Oktober 2006, 22:28

dankegut hat geschrieben: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. :D 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
Zuletzt geändert von gerold am Samstag 21. Oktober 2006, 22:53, insgesamt 1-mal geändert.
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5555
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Oberhofen im Inntal (Tirol)
Kontaktdaten:

Samstag 21. Oktober 2006, 22:50

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
:-)
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Benutzeravatar
Masaru
User
Beiträge: 425
Registriert: Mittwoch 4. August 2004, 22:17

Sonntag 22. Oktober 2006, 09:16

gerold hat geschrieben: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 :wink:. Kompliziertes "sollte" man natürlich nicht verwenden *g* ... gibt ja zum Glück auch einfacheres.
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5555
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Oberhofen im Inntal (Tirol)
Kontaktdaten:

Sonntag 22. Oktober 2006, 10:54

Masaru hat geschrieben: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
:-)
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
dankegut
User
Beiträge: 29
Registriert: Montag 16. Oktober 2006, 18:56
Kontaktdaten:

Montag 23. Oktober 2006, 09:16

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.
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5555
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Oberhofen im Inntal (Tirol)
Kontaktdaten:

Montag 23. Oktober 2006, 11:18

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
:-)
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
dankegut
User
Beiträge: 29
Registriert: Montag 16. Oktober 2006, 18:56
Kontaktdaten:

Sonntag 29. Oktober 2006, 16:29

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
Administrator
Beiträge: 16024
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Sonntag 29. Oktober 2006, 19:52

dankegut hat geschrieben: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.
My god, it's full of CARs! | Leonidasvoice vs Modvoice
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5555
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Oberhofen im Inntal (Tirol)
Kontaktdaten:

Sonntag 29. Oktober 2006, 23:36

dankegut hat geschrieben: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.
Zuletzt geändert von gerold am Montag 30. Oktober 2006, 12:22, insgesamt 1-mal geändert.
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5555
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Oberhofen im Inntal (Tirol)
Kontaktdaten:

Montag 30. Oktober 2006, 00:28

...

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.
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Antworten