moved keypairs to db using the same interface

4 files changed, 106 insertions, 21 deletions

diff --git a/nova/auth/manager.py b/nova/auth/manager.py
index d5fbec7c5..4cb23bea6 100644
--- a/nova/auth/manager.py
+++ b/nova/auth/manager.py
@@ -668,42 +668,36 @@ class AuthManager(object):
         with self.driver() as drv:
             if not drv.get_user(uid):
                 raise exception.NotFound("User %s doesn't exist" % user)
-            if drv.get_key_pair(uid, key_name):
-                raise exception.Duplicate("The keypair %s already exists"
-                                          % key_name)
+        try:
+            db.keypair_get(None, uid, key_name)
+            raise exception.Duplicate("The keypair %s already exists"
+                                      % key_name)
+        except exception.NotFound:
+            pass
         private_key, public_key, fingerprint = crypto.generate_key_pair()
         self.create_key_pair(uid, key_name, public_key, fingerprint)
         return private_key, fingerprint
 
     def create_key_pair(self, user, key_name, public_key, fingerprint):
         """Creates a key pair for user"""
-        with self.driver() as drv:
-            kp_dict = drv.create_key_pair(User.safe_id(user),
-                                          key_name,
-                                          public_key,
-                                          fingerprint)
-            if kp_dict:
-                return KeyPair(**kp_dict)
+        key = {}
+        key['user_id'] = User.safe_id(user)
+        key['name'] = key_name
+        key['public_key'] = public_key
+        key['fingerprint'] = fingerprint
+        return db.keypair_create(None, key)
 
     def get_key_pair(self, user, key_name):
         """Retrieves a key pair for user"""
-        with self.driver() as drv:
-            kp_dict = drv.get_key_pair(User.safe_id(user), key_name)
-            if kp_dict:
-                return KeyPair(**kp_dict)
+        return db.keypair_get(None, User.safe_id(user), key_name)
 
     def get_key_pairs(self, user):
         """Retrieves all key pairs for user"""
-        with self.driver() as drv:
-            kp_list = drv.get_key_pairs(User.safe_id(user))
-            if not kp_list:
-                return []
-            return [KeyPair(**kp_dict) for kp_dict in kp_list]
+        return db.keypair_get_all_by_user(None, User.safe_id(user))
 
     def delete_key_pair(self, user, key_name):
         """Deletes a key pair for user"""
-        with self.driver() as drv:
-            drv.delete_key_pair(User.safe_id(user), key_name)
+        return db.keypair_destroy(None, User.safe_id(user), key_name)
 
     def get_credentials(self, user, project=None):
         """Get credential zip for user in project"""
diff --git a/nova/db/api.py b/nova/db/api.py
index d81673fad..1db978c52 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -254,6 +254,29 @@ def instance_update(context, instance_id, values):
     return IMPL.instance_update(context, instance_id, values)
 
 
+###################
+
+
+def keypair_create(context, values):
+    """Create a keypair from the values dictionary."""
+    return IMPL.keypair_create(context, values)
+
+
+def keypair_destroy(context, user_id, name):
+    """Destroy the keypair or raise if it does not exist."""
+    return IMPL.keypair_destroy(context, user_id, name)
+
+
+def keypair_get(context, user_id, name):
+    """Get a keypair or raise if it does not exist."""
+    return IMPL.keypair_get(context, user_id, name)
+
+
+def keypair_get_all_by_user(context, user_id):
+    """Get all keypairs by user."""
+    return IMPL.keypair_get_all_by_user(context, user_id)
+
+
 ####################
 
 
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 02ebdd222..b3a307043 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -355,6 +355,38 @@ def instance_update(_context, instance_id, values):
 ###################
 
 
+def keypair_create(_context, values):
+    keypair_ref = models.Keypair()
+    for (key, value) in values.iteritems():
+        keypair_ref[key] = value
+    keypair_ref.save()
+    return keypair_ref
+
+
+def keypair_destroy(_context, user_id, name):
+    session = get_session()
+    with session.begin():
+        keypair_ref = models.Keypair.find_by_args(user_id,
+                                                  name,
+                                                  session=session)
+        keypair_ref.delete(session=session)
+
+
+def keypair_get(_context, user_id, name):
+    return models.Keypair.find_by_args(user_id, name)
+
+
+def keypair_get_all_by_user(_context, user_id):
+    session = get_session()
+    return session.query(models.Keypair
+                 ).filter_by(user_id=user_id
+                 ).filter_by(deleted=False
+                 ).all()
+
+
+###################
+
+
 def network_count(_context):
     return models.Network.count()
 
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 6818f838c..81c0a77a8 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -284,6 +284,42 @@ class ExportDevice(BASE, NovaBase):
                                                   uselist=False))
 
 
+class Keypair(BASE, NovaBase):
+    """Represents a keypair"""
+    __tablename__ = 'keypairs'
+    id = Column(Integer, primary_key=True)
+    name = Column(String(255))
+
+    user_id = Column(String(255))
+
+    fingerprint = Column(String(255))
+    public_key = Column(Text)
+
+    @property
+    def str_id(self):
+        return '%s.%s' % (self.user_id, self.name)
+
+    @classmethod
+    def find_by_str(cls, str_id, session=None, deleted=False):
+        user_id, _sep, name = str_id.partition('.')
+        return cls.find_by_str(user_id, name, session, deleted)
+
+    @classmethod
+    def find_by_args(cls, user_id, name, session=None, deleted=False):
+        if not session:
+            session = get_session()
+        try:
+            return session.query(cls
+                         ).filter_by(user_id=user_id
+                         ).filter_by(name=name
+                         ).filter_by(deleted=deleted
+                         ).one()
+        except exc.NoResultFound:
+            new_exc = exception.NotFound("No model for user %s, name %s" %
+                                         (user_id, name))
+            raise new_exc.__class__, new_exc, sys.exc_info()[2]
+
+
 class Network(BASE, NovaBase):
     """Represents a network"""
     __tablename__ = 'networks'