Code: Alles auswählen
def listAllKeys(self):
tmp = ''
for key in keys.itervalues():
tmp += str([key.algo, key.key, key.hashval, key.name, key.host]) + "\n"
bintmp = xmlrpclib.Binary(tmp)
return bintmp
Code: Alles auswählen
def listAllKeys(self):
tmp = ''
for key in keys.itervalues():
tmp += str([key.algo, key.key, key.hashval, key.name, key.host]) + "\n"
bintmp = xmlrpclib.Binary(tmp)
return bintmp
Code: Alles auswählen
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()
Code: Alles auswählen
def create_dbstructure(self):
"""
Erstellt die Tabellen
"""
cur = self.cur
conn = self.conn
# Erstellt die Tabelle falls sie noch nicht existiert.
# Dies wird durch die Abfrage IF EXIST erreicht die glücklicherweise
# auch in SQLite funktioniert :)
sql = """
CREATE TABLE IF NOT EXISTS 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()
Hi XtraNine!XtraNine hat geschrieben:Ich würde das nicht so umständlich machen sondern gleich ein "IF EXIST" einbauen.
Wünsch dir eine gute BesserungPS: Und jetzt gehe ich wieder ins Bett, meine Grippe ausschlafen.
Also EAFP oder? Naja, die Idee ist so Simple da hätte ich auch drauf kommen können Ehrliche Meinung? Hmm, Ich benutze "try: except:" zwar auch häufig aber es ist nicht mMn ein besonders guter Stil das permanent zu benutzen. Außerdem sehen 20 "try:, except:" Blöcke einfach nur hässliche aus (wie in meine momentanen Programm das ich ändern werde ^^)jens hat geschrieben:Und die harten Jungs, erzeugen einfach die Tabelle und fangen den Fehler, wenn diese schon existiert, mit try-except ab
Code: Alles auswählen
try:
filelist = self.get_filedata()
except Exception, e:
if not "doesn't exist" in str(e):
raise Exception(e)
self.page_msg.red("Error: %s" % e)
else:
self.create_table()
Code: Alles auswählen
def receiveKey(self, key):
# check if key exists
for k in keys.itervalues():
if k.key == key:
key = keys.get_key(key)
return key.algo, key.key, key.hashval, key.name, key.host
else:
return "Key not found"
Code: Alles auswählen
File "client.py", line 59, in run
print server.sendKey(key1)
Code: Alles auswählen
def sendKey(self, key_dict):
# check algorithm type
if key_dict["algo"] == "RSA":
# check if name/key already exists
for key in keys.itervalues():
if key.name == key_dict["name"]:
return "Name already exists"
else:
# save key if it doesn't exist
keys.set_rsa_key(key_dict["algo"],key_dict["key"],key_dict["hashval"],key_dict["name"],key_dict["host"])
return "successfully saved RSA Key"
if key_dict["algo"] == "ElGamal":
for k in keys.itervalues():
if k.name == key_dict["name"]:
return "Name already exists"
else:
keys.set_elgamal_key(key_dict["algo"], key_dict["key1"], key_dict["key2"],
key_dict["key3"], key_dict["hashval"], key_dict["name"], key_dict["host"])
return "successfully saved ElGamal Key"
else:
return "No valid Key"
Code: Alles auswählen
def send_key(self, key_dict):
algo_map = { 'RSA': (keys.set_rsa_key, ('algo', 'key', 'hashval',
'name', 'host')),
'ElGamal': (keys.set_elgamal_key, ('algo', 'key1', 'key2',
'key3', 'hashval',
'name', 'host')) }
algo_name = key_dict['algo']
if algo_name in algo_map:
name = key_dict['name']
for key in keys.itervalues():
if key.name == name and key.algo == algo_name:
return 'Name already exists'
set_func, attr_names = algo_map[algo_name]
set_func(*[key_dict[attr_name] for attr_name in attr_names])
return 'Successfully saved %s key' % algo_name
else:
return 'No valid Key'
Modul(e) im Interpretierer importieren und die Funktionen alle mal per Hand austesten und/oder Doctests und/oder Unit-Tests schreiben.dankegut hat geschrieben:vielleicht wer ne idee?
Ja das darf auch nicht einfach so vor einer List-Comprehension stehen, sondern ist Teil eines Funktionsaufrufes. In der Zeile ist das aber kein Funktionsaufruf, weil Du zwischen den Funtkionsnamen und die Argumente ein Komma gesetzt hast. Nimm das mal weg, dann sollte es gehen.dankegut hat geschrieben:Also beim * meckert er.Code: Alles auswählen
File "keyserver.py", line 119 set_func, (*[key_dict[attr_name] for attr_name in attr_names]) ^ SyntaxError: invalid syntax
`set_func` ist ein ganz normaler Name, den kannst Du auch durch etwas anderes ersetzen. Die Funktion, an die dieser Name gebunden ist, wird aus dem Dictionary `algo_map` geholt.diese Zeile und die davor verstehe ich leider auch nicht so ganz, da ich mit set_func noch nie gearbeitet habe.
Doch das ist schon richtig. Das ist ein Tupel mit zwei Werten, ein Funktionsobjekt und ein weiteres Tupel mit Zeichenketten. Und in dem Dictionary `algo_map` wird der Name des Algoritmus auf so ein Tupel abgebildet. Du kannst also über den Namen die entsprechende Funktion zum Hinzufügen eines Schlüssels und die Namen der Werte aus dem `key_dict` aus dem Dictionary holen.Also algo_map stellt ja ein dict dar, oder? Ich bin mir nicht sicher, ob das mit dem
(keys.set_rsa_key, ('algo', 'key', 'hashval',
'name', 'host'))
so richtig ist, wegen dem komma nach set_rsa_key?![/code]
Code: Alles auswählen
In [14]: max(1, 5, 4)
Out[14]: 5
In [15]: a = (max, (1, 5, 4))
In [16]: a[0]
Out[16]: <built-in function max>
In [17]: a[1]
Out[17]: (1, 5, 4)
In [18]: b = { 'maximum': (max, (1, 5, 4)) }
In [19]: b
Out[19]: {'maximum': (<built-in function max>, (1, 5, 4))}
In [20]: b['maximum']
Out[20]: (<built-in function max>, (1, 5, 4))
In [21]: func, values = b['maximum']
In [22]: func
Out[22]: <built-in function max>
In [23]: values
Out[23]: (1, 5, 4)
In [24]: func(*values)
Out[24]: 5
Code: Alles auswählen
import wx
class clientGUI(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.search = wx.StaticBitmap(self, -1, wx.Bitmap("images/keysearch.gif", wx.BITMAP_TYPE_ANY))
#self.upload = wx.StaticBitmap(self, -1, wx.Bitmap("images/uploadkey.gif", wx.BITMAP_TYPE_ANY))
#self.delete = wx.StaticBitmap(self, -1, wx.Bitmap("images/deletekey.gif", wx.BITMAP_TYPE_ANY))
self.searchTxt = wx.TextCtrl(self, -1, "")
self.searchB = wx.Button(self, -1, "search")
self.Bind(wx.EVT_BUTTON, self.searchKey, self.searchB)
self.__set_properties()
self.__do_layout()
def __set_properties(self):
# begin wxGlade: MyFrame.__set_properties
self.SetTitle("frame_1")
self.search.SetMinSize((100,100))
def __do_layout(self):
# begin wxGlade: MyFrame.__do_layout
sizer_1 = wx.BoxSizer(wx.VERTICAL)
sizer_2 = wx.BoxSizer(wx.VERTICAL)
grid_sizer_1 = wx.GridSizer(1, 3, 0, 0)
gs_KeyS = wx.GridSizer(1,2,0,0)
# adjust search key
grid_sizer_1.Add(self.search, 0, wx.ADJUST_MINSIZE, 0)
grid_sizer_1.Add(gs_KeyS, 1, wx.EXPAND, 0)
grid_sizer_1.Add(self.searchTxt, 0, wx.ADJUST_MINSIZE, 0)
grid_sizer_1.Add(self.searchB, 0, wx.ADJUST_MINSIZE, 0)
sizer_2.Add(grid_sizer_1, 1, wx.EXPAND, 0)
sizer_1.Add(sizer_2, 1, wx.EXPAND, 0)
self.SetAutoLayout(True)
self.SetSizer(sizer_1)
sizer_1.Fit(self)
sizer_1.SetSizeHints(self)
self.Layout()
def searchKey(self, event):
x = self.searchTxt.GetValue()
print x
def uploadKey():
pass
def deleteKey():
pass
if __name__ == "__main__":
app = wx.PySimpleApp(0)
frame = wx.Frame(None, -1, "Client",
size=(380, 380))
clientGUI(frame)
frame.Show(True)
app.MainLoop()
Code: Alles auswählen
class Client(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
def run(self):
server = xmlrpclib.Server("http://192.168.0.1:8000")