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()
Code: Alles auswählen
def listKeys(self):
key = open("test.xml")
return key.read()
Hi Masaru!Masaru hat geschrieben:XML-RPC "sollte" nie dazu dienen, ganze Dateninhalte zwischen zwei Punkten zu verschieben (Dateitransfer).
Hi dankegut!dankegut hat geschrieben:Kann ich dem Client jetzt sagen, dass er das in eine Datei schreiben soll ?! am besten noch mit dem gleichen dateinamen
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()
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()
Code: Alles auswählen
f_out = file("new_" + ret_dict["filename"], "wb")
f_out.write(ret_dict["content"].data)
f_out.close()
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 hat geschrieben:Warum soll man etwas komplizierteres dafür verwenden?
Hi Masaru!Masaru hat geschrieben:Kompliziertes "sollte" man natürlich nicht verwenden *g* ... gibt ja zum Glück auch einfacheres.
Hi dankegut!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?
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()
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()
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
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.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
Hi Christian!dankegut hat geschrieben:Desweiteren sehe ich noch Probleme bei einer SuchenOption. Habt ihr da vielleicht irgendwelche vorschläge?
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()
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()
Code: Alles auswählen
server.saveKey("rsa", "bla", "blub" "chris" "localhost")
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()
Hi Christian!dankegut hat geschrieben: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)
Code: Alles auswählen
self._shelve[str(key) = Key(algo, key, hashval, name, host)