assert primary key exists in record before attempting to delete it

[plcapi.git] / PLC / Keys.py

diff --git a/PLC/Keys.py b/PLC/Keys.py
index 60c39ff..07a05e4 100644 (file)
--- a/PLC/Keys.py
+++ b/PLC/Keys.py
@@ -15,41 +15,43 @@ class Key(NovaObject):
     with sync().
     """
 
-    table_name = 'keys'
-    primary_key = 'key_id'
+    tablename = 'keys'
     join_tables = ['person_key', 'peer_key']
     fields = {
-        'key_id': Parameter(str, "Key identifier"),
-        'key_type': Parameter(str, "Key type"),
-        'key': Parameter(str, "Key value", max = 4096),
-        'person_id': Parameter(int, "User to which this key belongs", nullok = True),
-        'peer_id': Parameter(int, "Peer to which this key belongs", nullok = True),
-        'peer_key_id': Parameter(int, "Foreign key identifier at peer", nullok = True),
+        'id': Parameter(str, "Key identifier", primary_key=True),
+        #'key_type': Parameter(str, "Key type"),
+        'public_key': Parameter(str, "Key string", max = 4096),
+        'name': Parameter(str, "Key name",)
         }
 
-    def validate_key_type(self, key_type):
-        key_types = [row['key_type'] for row in KeyTypes(self.api)]
-        if key_type not in key_types:
-            raise PLCInvalidArgument, "Invalid key type"
-        return key_type
+    def sync(self, insert = False, validate = True):
+        NovaObject.sync(self, insert, validate)
+        if insert == True or 'id' not in self:
+            self.object = self.api.client_shell.nova.keypairs.create(self.id,
+                                                                     self.key)
+        else:
+            self.object = self.api.client_shell.nova.keypairs.update(self.id, dict(self))
 
-    def validate_key(self, key):
-        # Key must not be blacklisted
-        rows = self.api.db.selectall("SELECT 1 from keys" \
-                                     " WHERE key = %(key)s" \
-                                     " AND is_blacklisted IS True",
-                                     locals())
-        if rows:
-            raise PLCInvalidArgument, "Key is blacklisted and cannot be used"
+    def delete(self):
+        assert 'id' in self
+        self.api.client_shell.nova.keypairs.delete(self.id)
 
+    def validate_public_key(self, key):
+        # Key must not be blacklisted
+        pass
         return key
 
+    def validate_name(self, name)
+        keys = Keys(self.api, name)
+        if keys:
+            raise PLCInvalidArgument, "Key name alredy in use"
+
     def validate(self):
         # Basic validation
-        Row.validate(self)
+        NovaObject.validate(self)
 
-        assert 'key' in self
-        key = self['key']
+        assert 'public_key' in self
+        key = self['public_key']
 
         if self['key_type'] == 'ssh':
             # Accept only SSH version 2 keys without options. From
@@ -110,7 +112,7 @@ class Keys(NovaTable):
         if key_filter is not None:
             if isinstance(key_filter, (list, tuple, set, int, long)):
                 keyPairs = filter(lambda kp: kp.uuid in key_filter,
-                                   keysManager.findall())
+                                  keysManager.findall())
             elif isinstance(key_filter, dict):
                 keyPairs = keysManager.findall(**key_filter)
             elif isinstnace(key_filter, StringTypes):