Save the adminPass if returned on server create

I am using the or, because if the server returns a None in the adminPass
field, but the admin_pass is set in kwargs, we should still want that
password, but a default on the .get in python wouldn't return it cause
the key is actually set to None.

Add admin_pass to rebuild_server

Change-Id: Iff3242ef916180018c3d878942a7af14988165b7

shade/openstackcloud.py

@@ -3267,6 +3267,7 @@ class OpenStackCloud(object):
             server = self.manager.submitTask(_tasks.ServerCreate(
                 name=name, flavor=flavor, **kwargs))
             server_id = server.id
+            admin_pass = server.get('adminPass') or kwargs.get('admin_pass')
             if not wait:
                 # This is a direct get task call to skip the list_servers
                 # cache which has absolutely no chance of containing the
@@ -3300,7 +3301,10 @@ class OpenStackCloud(object):
                     auto_ip=auto_ip, ips=ips, ip_pool=ip_pool,
                     wait=wait, timeout=timeout)
                 if server:
+                    server.adminPass = admin_pass
                     return server
+
+        server.adminPass = admin_pass
         return server
 
     def get_active_server(
@@ -3341,11 +3345,13 @@ class OpenStackCloud(object):
                 extra_data=dict(server=server))
         return None
 
-    def rebuild_server(self, server_id, image_id, wait=False, timeout=180):
+    def rebuild_server(self, server_id, image_id, admin_pass=None,
+                       wait=False, timeout=180):
         with _utils.shade_exceptions("Error in rebuilding instance"):
             server = self.manager.submitTask(_tasks.ServerRebuild(
-                server=server_id, image=image_id))
+                server=server_id, image=image_id, password=admin_pass))
         if wait:
+            admin_pass = server.get('adminPass') or admin_pass
             for count in _utils._iterate_timeout(
                     timeout,
                     "Timeout waiting for server {0} to "
@@ -3356,6 +3362,7 @@ class OpenStackCloud(object):
                     continue
 
                 if server['status'] == 'ACTIVE':
+                    server.adminPass = admin_pass
                     return server
 
                 if server['status'] == 'ERROR':

shade/tests/fakes.py

@@ -67,7 +67,8 @@ class FakeProject(object):
 class FakeServer(object):
     def __init__(
             self, id, name, status, addresses=None,
-            accessIPv4='', accessIPv6='', flavor=None, image=None):
+            accessIPv4='', accessIPv6='', flavor=None, image=None,
+            adminPass=None):
         self.id = id
         self.name = name
         self.status = status
@@ -80,6 +81,7 @@ class FakeServer(object):
         self.image = image
         self.accessIPv4 = accessIPv4
         self.accessIPv6 = accessIPv6
+        self.adminPass = adminPass
 
 
 class FakeService(object):

shade/tests/functional/test_compute.py

@@ -62,6 +62,21 @@ class TestCompute(base.TestCase):
         self.assertEqual(self.server_name, server['name'])
         self.assertEqual(self.image.id, server['image']['id'])
         self.assertEqual(self.flavor.id, server['flavor']['id'])
+        self.assertIsNotNone(server['adminPass'])
+        self.assertTrue(self.cloud.delete_server(self.server_name, wait=True))
+        self.assertIsNone(self.cloud.get_server(self.server_name))
+
+    def test_create_and_delete_server_with_admin_pass(self):
+        self.addCleanup(self._cleanup_servers_and_volumes, self.server_name)
+        server = self.cloud.create_server(name=self.server_name,
+                                          image=self.image,
+                                          flavor=self.flavor,
+                                          admin_pass='sheiqu9loegahSh',
+                                          wait=True)
+        self.assertEqual(self.server_name, server['name'])
+        self.assertEqual(self.image.id, server['image']['id'])
+        self.assertEqual(self.flavor.id, server['flavor']['id'])
+        self.assertEqual(server['adminPass'], 'sheiqu9loegahSh')
         self.assertTrue(self.cloud.delete_server(self.server_name, wait=True))
         self.assertIsNone(self.cloud.get_server(self.server_name))
 

shade/tests/unit/test_create_server.py

@@ -142,6 +142,66 @@ class TestCreateServer(base.TestCase):
                     name='server-name', image='image=id',
                     flavor='flavor-id'))
 
+    def test_create_server_with_admin_pass_no_wait(self):
+        """
+        Test that a server with an admin_pass passed returns the password
+        """
+        with patch("shade.OpenStackCloud"):
+            fake_server = fakes.FakeServer('1234', '', 'BUILD')
+            fake_create_server = fakes.FakeServer('1234', '', 'BUILD',
+                                                  adminPass='ooBootheiX0edoh')
+            config = {
+                "servers.create.return_value": fake_create_server,
+                "servers.get.return_value": fake_server
+            }
+            OpenStackCloud.nova_client = Mock(**config)
+            self.assertEqual(
+                _utils.normalize_server(
+                    meta.obj_to_dict(fake_create_server),
+                    cloud_name=self.client.name,
+                    region_name=self.client.region_name),
+                self.client.create_server(
+                    name='server-name', image='image=id',
+                    flavor='flavor-id', admin_pass='ooBootheiX0edoh'))
+
+    def test_create_server_with_admin_pass_wait(self):
+        """
+        Test that a server with an admin_pass passed returns the password
+        """
+        with patch("shade.OpenStackCloud"):
+            build_server = fakes.FakeServer(
+                '1234', '', 'BUILD', addresses=dict(public='1.1.1.1'),
+                adminPass='ooBootheiX0edoh')
+            next_server = fakes.FakeServer(
+                '1234', '', 'BUILD', addresses=dict(public='1.1.1.1'))
+            fake_server = fakes.FakeServer(
+                '1234', '', 'ACTIVE', addresses=dict(public='1.1.1.1'))
+            ret_fake_server = fakes.FakeServer(
+                '1234', '', 'ACTIVE', addresses=dict(public='1.1.1.1'),
+                adminPass='ooBootheiX0edoh')
+            config = {
+                "servers.create.return_value": build_server,
+                "servers.get.return_value": next_server,
+                "servers.list.side_effect": [
+                    [next_server], [fake_server]]
+            }
+            OpenStackCloud.nova_client = Mock(**config)
+            with patch.object(OpenStackCloud, "add_ips_to_server",
+                              return_value=fake_server):
+                self.assertEqual(
+                    _utils.normalize_server(
+                        meta.obj_to_dict(ret_fake_server),
+                        cloud_name=self.client.name,
+                        region_name=self.client.region_name),
+                    _utils.normalize_server(
+                        meta.obj_to_dict(
+                            self.client.create_server(
+                                'server-name', 'image-id', 'flavor-id',
+                                wait=True, admin_pass='ooBootheiX0edoh')),
+                        cloud_name=self.client.name,
+                        region_name=self.client.region_name)
+                )
+
     def test_create_server_wait(self):
         """
         Test that create_server with a wait returns the server instance when

shade/tests/unit/test_rebuild_server.py

@@ -96,6 +96,45 @@ class TestRebuildServer(base.TestCase):
             self.assertEqual(meta.obj_to_dict(rebuild_server),
                              self.client.rebuild_server("a", "b"))
 
+    def test_rebuild_server_with_admin_pass_no_wait(self):
+        """
+        Test that a server with an admin_pass passed returns the password
+        """
+        with patch("shade.OpenStackCloud"):
+            rebuild_server = fakes.FakeServer('1234', '', 'REBUILD',
+                                              adminPass='ooBootheiX0edoh')
+            config = {
+                "servers.rebuild.return_value": rebuild_server,
+            }
+            OpenStackCloud.nova_client = Mock(**config)
+            self.assertEqual(
+                meta.obj_to_dict(rebuild_server),
+                self.client.rebuild_server('a', 'b',
+                                           admin_pass='ooBootheiX0edoh'))
+
+    def test_rebuild_server_with_admin_pass_wait(self):
+        """
+        Test that a server with an admin_pass passed returns the password
+        """
+        with patch("shade.OpenStackCloud"):
+            rebuild_server = fakes.FakeServer('1234', '', 'REBUILD',
+                                              adminPass='ooBootheiX0edoh')
+            active_server = fakes.FakeServer('1234', '', 'ACTIVE')
+            ret_active_server = fakes.FakeServer('1234', '', 'ACTIVE',
+                                                 adminPass='ooBootheiX0edoh')
+            config = {
+                "servers.rebuild.return_value": rebuild_server,
+                "servers.get.return_value": active_server,
+            }
+            OpenStackCloud.nova_client = Mock(**config)
+            self.client.name = 'cloud-name'
+            self.assertEqual(
+                _utils.normalize_server(
+                    meta.obj_to_dict(ret_active_server),
+                    cloud_name='cloud-name', region_name=''),
+                self.client.rebuild_server("a", "b", wait=True,
+                                           admin_pass='ooBootheiX0edoh'))
+
     def test_rebuild_server_wait(self):
         """
         Test that rebuild_server with a wait returns the server instance when