Added get() method to keypair service and made the find() method return

a list, to improve consistency with other services. Closes issue:
https://github.com/gvlproject/cloudbridge/issues/8

cloudbridge/cloud/base.py

@@ -719,19 +719,19 @@ class BaseKeyPairService(
     def __init__(self, provider):
         super(BaseKeyPairService, self).__init__(provider)
 
-    def delete(self, name):
+    def delete(self, keypair_id):
         """
         Delete an existing key pair.
 
-        :type name: str
-        :param name: The name of the key pair to be deleted.
+        :type keypair_id: str
+        :param keypair_id: The id 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)
+        kp = self.get(keypair_id)
         if kp:
             kp.delete()
         return True

cloudbridge/cloud/interfaces/services.py

@@ -623,6 +623,25 @@ class KeyPairService(PageableObjectMixin, ProviderService):
     """
     __metaclass__ = ABCMeta
 
+    @abstractmethod
+    def get(self, keypair_id):
+        """
+        Returns a KeyPair given its ID. Returns ``None`` if the KeyPair
+        does not exist. On some providers, such as AWS and Openstack,
+        the KeyPair id is the same as its name.
+
+        Example:
+
+        .. code-block:: python
+
+            keypair = provider.security.keypairs.get('my_keypair_id')
+            print(keypair.id, keypair.name)
+
+        :rtype: :class:`.KeyPair`
+        :return:  a KeyPair instance
+        """
+        pass
+
     @abstractmethod
     def list(self, limit=None, marker=None):
         """
@@ -634,7 +653,7 @@ class KeyPairService(PageableObjectMixin, ProviderService):
         pass
 
     @abstractmethod
-    def find(self, name):
+    def find(self, name, limit=None, marker=None):
         """
         Searches for a key pair by a given list of attributes.
 
@@ -657,12 +676,12 @@ class KeyPairService(PageableObjectMixin, ProviderService):
         pass
 
     @abstractmethod
-    def delete(self, name):
+    def delete(self, keypair_id):
         """
         Delete an existing SecurityGroup.
 
-        :type name: str
-        :param name: The name of the key pair to be deleted.
+        :type keypair_id: str
+        :param keypair_id: The id of the key pair to be deleted.
 
         :rtype: ``bool``
         :return:  ``True`` if the key does not exist, ``False`` otherwise. Note

cloudbridge/cloud/providers/aws/services.py

@@ -79,6 +79,17 @@ class AWSKeyPairService(BaseKeyPairService):
     def __init__(self, provider):
         super(AWSKeyPairService, self).__init__(provider)
 
+    def get(self, keypair_id):
+        """
+        Returns a KeyPair given its id.
+        """
+        try:
+            kps = self.provider.ec2_conn.get_all_key_pairs(
+                keynames=[keypair_id])
+            return AWSKeyPair(self.provider, kps[0])
+        except EC2ResponseError:
+            return None
+
     def list(self, limit=None, marker=None):
         """
         List all key pairs associated with this account.
@@ -91,15 +102,18 @@ class AWSKeyPairService(BaseKeyPairService):
         return ClientPagedResultList(self.provider, key_pairs,
                                      limit=limit, marker=marker)
 
-    def find(self, name):
+    def find(self, name, limit=None, marker=None):
         """
         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)
+            key_pairs = [
+                AWSKeyPair(self.provider, kp) for kp in
+                self.provider.ec2_conn.get_all_key_pairs(keynames=[name])]
         except EC2ResponseError:
-            return None
+            key_pairs = []
+        return ClientPagedResultList(self.provider, key_pairs,
+                                     limit=limit, marker=marker)
 
     def create(self, name):
         """
@@ -111,7 +125,7 @@ class AWSKeyPairService(BaseKeyPairService):
         :rtype: ``object`` of :class:`.KeyPair`
         :return:  A keypair instance or None if one was not be created.
         """
-        kp = self.find(name=name)
+        kp = self.get(name)
         if kp:
             return kp
         kp = self.provider.ec2_conn.create_key_pair(name)

cloudbridge/cloud/providers/openstack/services.py

@@ -77,6 +77,16 @@ class OpenStackKeyPairService(BaseKeyPairService):
     def __init__(self, provider):
         super(OpenStackKeyPairService, self).__init__(provider)
 
+    def get(self, keypair_id):
+        """
+        Returns a KeyPair given its id.
+        """
+        try:
+            return OpenStackKeyPair(
+                self.provider, self.provider.nova.keypairs.get(keypair_id))
+        except NovaNotFound:
+            return None
+
     def list(self, limit=None, marker=None):
         """
         List all key pairs associated with this account.
@@ -91,15 +101,15 @@ class OpenStackKeyPairService(BaseKeyPairService):
         return ClientPagedResultList(self.provider, results,
                                      limit=limit, marker=marker)
 
-    def find(self, name):
+    def find(self, name, limit=None, marker=None):
         """
         Searches for a key pair by a given list of attributes.
         """
-        try:
-            kp = self.provider.nova.keypairs.find(name=name)
-            return OpenStackKeyPair(self.provider, kp)
-        except NovaNotFound:
-            return None
+        keypairs = self.provider.nova.keypairs.findall(name=name)
+        results = [OpenStackKeyPair(self.provider, kp)
+                   for kp in keypairs]
+        return ClientPagedResultList(self.provider, results,
+                                     limit=limit, marker=marker)
 
     def create(self, name):
         """
@@ -111,7 +121,7 @@ class OpenStackKeyPairService(BaseKeyPairService):
         :rtype: ``object`` of :class:`.KeyPair`
         :return:  A keypair instance or ``None`` if one was not be created.
         """
-        kp = self.find(name=name)
+        kp = self.get(name)
         if kp:
             return kp
         kp = self.provider.nova.keypairs.create(name)

test/test_security_service.py

@@ -15,29 +15,38 @@ class CloudSecurityServiceTestCase(ProviderTestBase):
         kp = self.provider.security.key_pairs.create(name=name)
         with helpers.cleanup_action(
             lambda:
-                self.provider.security.key_pairs.delete(name=kp.name)
+                self.provider.security.key_pairs.delete(kp.id)
         ):
             # test list method
             kpl = self.provider.security.key_pairs.list()
-            found_kpl = [i for i in kpl if i.name == name]
+            list_kpl = [i for i in kpl if i.name == name]
             self.assertTrue(
-                len(found_kpl) == 1,
+                len(list_kpl) == 1,
                 "List keypairs does not return the expected keypair %s" %
                 name)
 
             # check iteration
-            found_kpl = [i for i in self.provider.security.key_pairs
-                         if i.name == name]
+            iter_kpl = [i for i in self.provider.security.key_pairs
+                        if i.name == name]
             self.assertTrue(
-                len(found_kpl) == 1,
+                len(iter_kpl) == 1,
                 "Iter keypairs does not return the expected keypair %s" %
                 name)
 
-            found_kp = self.provider.security.key_pairs.find(name=name)
+            # check find
+            find_kp = self.provider.security.key_pairs.find(name=name)[0]
             self.assertTrue(
-                found_kp == kp,
+                find_kp == kp,
                 "Find key pair did not return the expected key {0}."
                 .format(name))
+
+            # check get
+            get_kp = self.provider.security.key_pairs.get(name)
+            self.assertTrue(
+                get_kp == kp,
+                "Get key pair did not return the expected key {0}."
+                .format(name))
+
             recreated_kp = self.provider.security.key_pairs.create(name=name)
             self.assertTrue(
                 recreated_kp == kp,
@@ -50,8 +59,8 @@ class CloudSecurityServiceTestCase(ProviderTestBase):
             "Key pair {0} should have been deleted but still exists."
             .format(name))
         no_kp = self.provider.security.key_pairs.find(name='bogus_kp')
-        self.assertTrue(
-            no_kp is None,
+        self.assertFalse(
+            no_kp,
             "Found a key pair {0} that should not exist?".format(no_kp))
 
     def test_key_pair(self):