Add find method to KeyPairService; refactor the code some

cloudbridge/cloud/base.py

@@ -496,6 +496,23 @@ class BaseKeyPairService(KeyPairService, BaseProviderService):
     def __init__(self, provider):
         super(BaseKeyPairService, self).__init__(provider)
 
+    def delete(self, name):
+        """
+        Delete an existing key pair.
+
+        :type name: str
+        :param name: The name of the key pair to be deleted.
+
+        :rtype: ``bool``
+        :return:  ``True`` if the key does not exist. Note that this implies
+                  that the key may not have been deleted by this method but
+                  instead has not existed in the first place.
+        """
+        kp = self.find(name=name)
+        if kp:
+            kp.delete()
+        return True
+
 
 class BaseSecurityGroupService(SecurityGroupService, BaseProviderService):
 

cloudbridge/cloud/interfaces/services.py

@@ -459,10 +459,20 @@ class KeyPairService(ProviderService):
         """
         pass
 
+    @abstractmethod
+    def find(self, name):
+        """
+        Searches for a key pair by a given list of attributes.
+
+        :rtype: ``object`` of :class:`.KeyPair`
+        :return:  a KeyPair object
+        """
+        pass
+
     @abstractmethod
     def create(self, name):
         """
-        Create a new keypair.
+        Create a new keypair or return an existing one by the same name.
 
         :type name: str
         :param name: The name of the key pair to be created.

cloudbridge/cloud/providers/aws/services.py

@@ -85,9 +85,19 @@ class AWSKeyPairService(BaseKeyPairService):
         key_pairs = self.provider.ec2_conn.get_all_key_pairs()
         return [AWSKeyPair(self.provider, kp) for kp in key_pairs]
 
+    def find(self, name):
+        """
+        Searches for a key pair by a given list of attributes.
+        """
+        try:
+            kp = self.provider.ec2_conn.get_all_key_pairs([name])[0]
+            return AWSKeyPair(self.provider, kp)
+        except EC2ResponseError:
+            return None
+
     def create(self, name):
         """
-        Create a new key pair.
+        Create a new keypair or return an existing one by the same name.
 
         :type name: str
         :param name: The name of the key pair to be created.
@@ -95,28 +105,11 @@ class AWSKeyPairService(BaseKeyPairService):
         :rtype: ``object`` of :class:`.KeyPair`
         :return:  A keypair instance or None if one was not be created.
         """
-        kp = self.provider.ec2_conn.create_key_pair(name)
+        kp = self.find(name=name)
         if kp:
-            return AWSKeyPair(self.provider, kp)
-        return None
-
-    def delete(self, name):
-        """
-        Delete an existing key pair.
-
-        :type name: str
-        :param name: The name of the key pair to be deleted.
-
-        :rtype: ``bool``
-        :return:  ``True`` if the key does not exist, ``False`` otherwise. Note
-                  that this implies that the key may not have been deleted by
-                  this method but instead has not existed in the first place.
-        """
-        for kp in self.provider.ec2_conn.get_all_key_pairs():
-            if kp.name == name:
-                kp.delete()
-                return True
-        return True
+            return kp
+        kp = self.provider.ec2_conn.create_key_pair(name)
+        return AWSKeyPair(self.provider, kp)
 
 
 class AWSSecurityGroupService(BaseSecurityGroupService):

cloudbridge/cloud/providers/openstack/services.py

@@ -81,39 +81,31 @@ class OpenStackKeyPairService(BaseKeyPairService):
         key_pairs = self._provider.nova.keypairs.list()
         return [OpenStackKeyPair(self._provider, kp) for kp in key_pairs]
 
-    def create(self, name):
+    def find(self, name):
         """
-        Create a new key pair.
-
-        :type name: str
-        :param name: The name of the key pair to be created.
-
-        :rtype: ``object`` of :class:`.KeyPair`
-        :return:  A keypair instance or None if one was not be created.
+        Searches for a key pair by a given list of attributes.
         """
-        kp = self._provider.nova.keypairs.create(name)
-        if kp:
+        try:
+            kp = self._provider.nova.keypairs.find(name=name)
             return OpenStackKeyPair(self._provider, kp)
-        return None
+        except NovaNotFound:
+            return None
 
-    def delete(self, name):
+    def create(self, name):
         """
-        Delete an existing key pair.
+        Create a new keypair or return an existing one by the same name.
 
         :type name: str
-        :param name: The name of the key pair to be deleted.
+        :param name: The name of the key pair to be created.
 
-        :rtype: ``bool``
-        :return:  ``True`` if the key does not exist, ``False`` otherwise. Note
-                  that this implies that the key may not have been deleted by
-                  this method but instead has not existed in the first place.
+        :rtype: ``object`` of :class:`.KeyPair`
+        :return:  A keypair instance or ``None`` if one was not be created.
         """
-        try:
-            kp = self._provider.nova.keypairs.find(name=name)
-            kp.delete()
-            return True
-        except NovaNotFound:
-            return True
+        kp = self.find(name=name)
+        if kp:
+            return kp
+        kp = self._provider.nova.keypairs.create(name)
+        return OpenStackKeyPair(self._provider, kp)
 
 
 class OpenStackSecurityGroupService(BaseSecurityGroupService):

test/test_provider_security_service.py

@@ -16,11 +16,10 @@ class ProviderSecurityServiceTestCase(ProviderTestBase):
             lambda:
                 self.provider.security.key_pairs.delete(name=kp.name)
         ):
-            kpl = self.provider.security.key_pairs.list()
-            found_kp = [k for k in kpl if k.name == name]
+            found_kp = self.provider.security.key_pairs.find(name=name)
             self.assertTrue(
-                len(found_kp) == 1,
-                "List key pairs did not return the expected key {0}."
+                found_kp == kp,
+                "Find key pair did not return the expected key {0}."
                 .format(name))
         kpl = self.provider.security.key_pairs.list()
         found_kp = [k for k in kpl if k.name == name]
@@ -28,9 +27,9 @@ class ProviderSecurityServiceTestCase(ProviderTestBase):
             len(found_kp) == 0,
             "Key pair {0} should have been deleted but still exists."
             .format(name))
-        no_kp = self.provider.security.key_pairs.delete(name='bogus_kp')
+        no_kp = self.provider.security.key_pairs.find(name='bogus_kp')
         self.assertTrue(
-            no_kp,
+            no_kp is None,
             "Found a key pair {0} that should not exist?".format(no_kp))
 
     def test_key_pair(self):