ZhiQiang Fan | 39f9722 | 2013-09-20 04:49:44 +0800 | [diff] [blame] | 1 | # Copyright 2012 OpenStack Foundation |
Jay Pipes | 13b479b | 2012-06-11 14:52:27 -0400 | [diff] [blame] | 2 | # All Rights Reserved. |
| 3 | # |
| 4 | # Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 5 | # not use this file except in compliance with the License. You may obtain |
| 6 | # a copy of the License at |
| 7 | # |
| 8 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | # |
| 10 | # Unless required by applicable law or agreed to in writing, software |
| 11 | # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 12 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 13 | # License for the specific language governing permissions and limitations |
| 14 | # under the License. |
| 15 | |
songwenping | 99d6e00 | 2021-01-05 03:07:46 +0000 | [diff] [blame] | 16 | from urllib import parse as urlparse |
| 17 | |
Cady_Chen | 72014bc | 2016-11-16 09:43:49 +0800 | [diff] [blame] | 18 | from oslo_log import log as logging |
ivan-zhu | 1feeb38 | 2013-01-24 10:14:39 +0800 | [diff] [blame] | 19 | import testtools |
Jay Pipes | 13b479b | 2012-06-11 14:52:27 -0400 | [diff] [blame] | 20 | |
Sean Dague | 1937d09 | 2013-05-17 16:36:38 -0400 | [diff] [blame] | 21 | from tempest.api.compute import base |
ghanshyam | 017b5fe | 2016-04-15 18:49:26 +0900 | [diff] [blame] | 22 | from tempest.common import compute |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 23 | from tempest.common import utils |
Masayuki Igawa | 209fd50 | 2014-02-17 14:46:43 +0900 | [diff] [blame] | 24 | from tempest.common.utils.linux import remote_client |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 25 | from tempest.common import waiters |
Sean Dague | 86bd842 | 2013-12-20 09:56:44 -0500 | [diff] [blame] | 26 | from tempest import config |
Felipe Monteiro | 9ff5c28 | 2017-06-21 21:05:07 +0100 | [diff] [blame] | 27 | from tempest.lib.common import api_version_utils |
Ken'ichi Ohmichi | 757833a | 2017-03-10 10:30:30 -0800 | [diff] [blame] | 28 | from tempest.lib.common.utils import data_utils |
Andrea Frittoli (andreaf) | db9672e | 2016-02-23 14:07:24 -0500 | [diff] [blame] | 29 | from tempest.lib import decorators |
| 30 | from tempest.lib import exceptions as lib_exc |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 31 | |
Sean Dague | 86bd842 | 2013-12-20 09:56:44 -0500 | [diff] [blame] | 32 | CONF = config.CONF |
| 33 | |
Ryan Hsu | 3823109 | 2014-06-08 23:12:10 -0700 | [diff] [blame] | 34 | LOG = logging.getLogger(__name__) |
| 35 | |
Daryl Walleck | c725196 | 2012-03-12 17:26:54 -0500 | [diff] [blame] | 36 | |
ivan-zhu | f2b0050 | 2013-10-18 10:06:52 +0800 | [diff] [blame] | 37 | class ServerActionsTestJSON(base.BaseV2ComputeTest): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 38 | """Test server actions""" |
| 39 | |
Attila Fazekas | 19044d5 | 2013-02-16 07:35:06 +0100 | [diff] [blame] | 40 | def setUp(self): |
Matt Riedemann | 2da5859 | 2014-06-08 12:46:02 +0000 | [diff] [blame] | 41 | # NOTE(afazekas): Normally we use the same server with all test cases, |
| 42 | # but if it has an issue, we build a new one |
Attila Fazekas | 19044d5 | 2013-02-16 07:35:06 +0100 | [diff] [blame] | 43 | super(ServerActionsTestJSON, self).setUp() |
Matt Riedemann | 2da5859 | 2014-06-08 12:46:02 +0000 | [diff] [blame] | 44 | # Check if the server is in a clean state after test |
| 45 | try: |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 46 | self.validation_resources = self.get_class_validation_resources( |
Martin Kopec | 78b960f | 2022-02-08 17:18:02 +0000 | [diff] [blame] | 47 | self.os_primary) |
| 48 | # _test_rebuild_server test compares ip address attached to the |
| 49 | # server before and after the rebuild, in order to avoid |
| 50 | # a situation when a newly created server doesn't have a floating |
| 51 | # ip attached at the beginning of the test_rebuild_server let's |
| 52 | # make sure right here the floating ip is attached |
| 53 | waiters.wait_for_server_floating_ip( |
| 54 | self.client, |
| 55 | self.client.show_server(self.server_id)['server'], |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 56 | self.validation_resources['floating_ip']) |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 57 | waiters.wait_for_server_status(self.client, |
| 58 | self.server_id, 'ACTIVE') |
Viktor Tikkanen | 1b0ce23 | 2015-05-28 10:21:27 +0300 | [diff] [blame] | 59 | except lib_exc.NotFound: |
| 60 | # The server was deleted by previous test, create a new one |
Andrea Frittoli | 9f416dd | 2017-08-10 15:38:00 +0100 | [diff] [blame] | 61 | # Use class level validation resources to avoid them being |
| 62 | # deleted once a test is over |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 63 | self.validation_resources = self.get_class_validation_resources( |
Andrea Frittoli | 9f416dd | 2017-08-10 15:38:00 +0100 | [diff] [blame] | 64 | self.os_primary) |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 65 | server = self.create_test_server( |
| 66 | validatable=True, |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 67 | validation_resources=self.validation_resources, |
Artom Lifshitz | 4fc47f6 | 2022-05-05 14:17:27 -0400 | [diff] [blame] | 68 | wait_until='SSHABLE') |
Viktor Tikkanen | 1b0ce23 | 2015-05-28 10:21:27 +0300 | [diff] [blame] | 69 | self.__class__.server_id = server['id'] |
Matt Riedemann | 2da5859 | 2014-06-08 12:46:02 +0000 | [diff] [blame] | 70 | except Exception: |
| 71 | # Rebuild server if something happened to it during a test |
zhufl | ba0e553 | 2017-09-13 10:51:07 +0800 | [diff] [blame] | 72 | self.__class__.server_id = self.recreate_server( |
Artom Lifshitz | 4fc47f6 | 2022-05-05 14:17:27 -0400 | [diff] [blame] | 73 | self.server_id, validatable=True, wait_until='SSHABLE') |
Matt Riedemann | 2da5859 | 2014-06-08 12:46:02 +0000 | [diff] [blame] | 74 | |
| 75 | def tearDown(self): |
Matt Riedemann | 2da5859 | 2014-06-08 12:46:02 +0000 | [diff] [blame] | 76 | super(ServerActionsTestJSON, self).tearDown() |
zhufl | e913e46 | 2018-07-25 17:16:10 +0800 | [diff] [blame] | 77 | # NOTE(zhufl): Because server_check_teardown will raise Exception |
| 78 | # which will prevent other cleanup steps from being executed, so |
| 79 | # server_check_teardown should be called after super's tearDown. |
| 80 | self.server_check_teardown() |
Attila Fazekas | 305e65b | 2013-10-29 13:23:07 +0100 | [diff] [blame] | 81 | |
Attila Fazekas | 19044d5 | 2013-02-16 07:35:06 +0100 | [diff] [blame] | 82 | @classmethod |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 83 | def setup_credentials(cls): |
| 84 | cls.prepare_instance_network() |
| 85 | super(ServerActionsTestJSON, cls).setup_credentials() |
| 86 | |
| 87 | @classmethod |
Rohan Kanade | 60b7309 | 2015-02-04 17:58:19 +0530 | [diff] [blame] | 88 | def setup_clients(cls): |
| 89 | super(ServerActionsTestJSON, cls).setup_clients() |
| 90 | cls.client = cls.servers_client |
| 91 | |
| 92 | @classmethod |
Andrea Frittoli | 50bb80d | 2014-09-15 12:34:27 +0100 | [diff] [blame] | 93 | def resource_setup(cls): |
Andrea Frittoli | 50bb80d | 2014-09-15 12:34:27 +0100 | [diff] [blame] | 94 | super(ServerActionsTestJSON, cls).resource_setup() |
Artom Lifshitz | 34ea7e9 | 2022-05-24 10:48:56 -0400 | [diff] [blame] | 95 | cls.server_id = cls.recreate_server(None, validatable=True, |
| 96 | wait_until='SSHABLE') |
Attila Fazekas | 19044d5 | 2013-02-16 07:35:06 +0100 | [diff] [blame] | 97 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 98 | @decorators.idempotent_id('6158df09-4b82-4ab3-af6d-29cf36af858d') |
Sean Dague | 86bd842 | 2013-12-20 09:56:44 -0500 | [diff] [blame] | 99 | @testtools.skipUnless(CONF.compute_feature_enabled.change_password, |
ivan-zhu | 1feeb38 | 2013-01-24 10:14:39 +0800 | [diff] [blame] | 100 | 'Change password not available.') |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 101 | def test_change_server_password(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 102 | """Test changing server's password |
| 103 | |
| 104 | The server's password should be set to the provided password and |
| 105 | the user can authenticate with the new password. |
| 106 | """ |
Emily Hugenbruch | 1315e18 | 2016-10-10 17:34:06 -0400 | [diff] [blame] | 107 | # Since this test messes with the password and makes the |
| 108 | # server unreachable, it should create its own server |
| 109 | newserver = self.create_test_server( |
| 110 | validatable=True, |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 111 | validation_resources=self.validation_resources, |
Emily Hugenbruch | 1315e18 | 2016-10-10 17:34:06 -0400 | [diff] [blame] | 112 | wait_until='ACTIVE') |
zhangyangyang | c248f59 | 2019-04-24 18:54:52 +0800 | [diff] [blame] | 113 | self.addCleanup(self.delete_server, newserver['id']) |
Sean Dague | 4dd2c0b | 2013-01-03 17:50:28 -0500 | [diff] [blame] | 114 | # The server's password should be set to the provided password |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 115 | new_password = 'Newpass1234' |
Emily Hugenbruch | 1315e18 | 2016-10-10 17:34:06 -0400 | [diff] [blame] | 116 | self.client.change_password(newserver['id'], adminPass=new_password) |
| 117 | waiters.wait_for_server_status(self.client, newserver['id'], 'ACTIVE') |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 118 | |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 119 | if CONF.validation.run_validation: |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 120 | # Verify that the user can authenticate with the new password |
Emily Hugenbruch | 1315e18 | 2016-10-10 17:34:06 -0400 | [diff] [blame] | 121 | server = self.client.show_server(newserver['id'])['server'] |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 122 | linux_client = remote_client.RemoteClient( |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 123 | self.get_server_ip(server, self.validation_resources), |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 124 | self.ssh_user, |
Andrea Frittoli (andreaf) | 2a70a61 | 2016-04-29 16:09:13 -0500 | [diff] [blame] | 125 | new_password, |
| 126 | server=server, |
| 127 | servers_client=self.client) |
Attila Fazekas | ad7ef7d | 2013-11-20 10:12:53 +0100 | [diff] [blame] | 128 | linux_client.validate_authentication() |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 129 | |
Ken'ichi Ohmichi | 84d7fbc | 2014-09-30 01:42:33 +0000 | [diff] [blame] | 130 | def _test_reboot_server(self, reboot_type): |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 131 | if CONF.validation.run_validation: |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 132 | # Get the time the server was last rebooted, |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 133 | server = self.client.show_server(self.server_id)['server'] |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 134 | linux_client = remote_client.RemoteClient( |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 135 | self.get_server_ip(server, self.validation_resources), |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 136 | self.ssh_user, |
| 137 | self.password, |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 138 | self.validation_resources['keypair']['private_key'], |
Andrea Frittoli (andreaf) | 2a70a61 | 2016-04-29 16:09:13 -0500 | [diff] [blame] | 139 | server=server, |
| 140 | servers_client=self.client) |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 141 | boot_time = linux_client.get_boot_time() |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 142 | |
Ken'ichi Ohmichi | 05ab856 | 2016-07-12 00:06:18 -0700 | [diff] [blame] | 143 | # NOTE: This sync is for avoiding the loss of pub key data |
| 144 | # in a server |
| 145 | linux_client.exec_command("sync") |
| 146 | |
Artom Lifshitz | ea2b59c | 2021-08-19 14:34:00 -0400 | [diff] [blame] | 147 | self.reboot_server(self.server_id, type=reboot_type) |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 148 | |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 149 | if CONF.validation.run_validation: |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 150 | # Log in and verify the boot time has changed |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 151 | linux_client = remote_client.RemoteClient( |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 152 | self.get_server_ip(server, self.validation_resources), |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 153 | self.ssh_user, |
| 154 | self.password, |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 155 | self.validation_resources['keypair']['private_key'], |
Andrea Frittoli (andreaf) | 2a70a61 | 2016-04-29 16:09:13 -0500 | [diff] [blame] | 156 | server=server, |
| 157 | servers_client=self.client) |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 158 | new_boot_time = linux_client.get_boot_time() |
Béla Vancsics | 64862f7 | 2016-11-08 09:12:31 +0100 | [diff] [blame] | 159 | self.assertGreater(new_boot_time, boot_time, |
| 160 | '%s > %s' % (new_boot_time, boot_time)) |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 161 | |
Jordan Pittier | 3b46d27 | 2017-04-12 16:17:28 +0200 | [diff] [blame] | 162 | @decorators.attr(type='smoke') |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 163 | @decorators.idempotent_id('2cb1baf6-ac8d-4429-bf0d-ba8a0ba53e32') |
Ken'ichi Ohmichi | 84d7fbc | 2014-09-30 01:42:33 +0000 | [diff] [blame] | 164 | def test_reboot_server_hard(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 165 | """Test hard rebooting server |
| 166 | |
| 167 | The server should be power cycled. |
| 168 | """ |
Ken'ichi Ohmichi | 84d7fbc | 2014-09-30 01:42:33 +0000 | [diff] [blame] | 169 | self._test_reboot_server('HARD') |
| 170 | |
lianghao | fd8d315 | 2017-04-01 15:34:26 +0800 | [diff] [blame] | 171 | @decorators.idempotent_id('1d1c9104-1b0a-11e7-a3d4-fa163e65f5ce') |
| 172 | def test_remove_server_all_security_groups(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 173 | """Test removing all security groups from server""" |
lianghao | fd8d315 | 2017-04-01 15:34:26 +0800 | [diff] [blame] | 174 | server = self.create_test_server(wait_until='ACTIVE') |
| 175 | |
| 176 | # Remove all Security group |
| 177 | self.client.remove_security_group( |
| 178 | server['id'], name=server['security_groups'][0]['name']) |
| 179 | |
| 180 | # Verify all Security group |
| 181 | server = self.client.show_server(server['id'])['server'] |
| 182 | self.assertNotIn('security_groups', server) |
| 183 | |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 184 | def _rebuild_server_and_check(self, image_ref, server): |
| 185 | rebuilt_server = (self.client.rebuild_server(server['id'], image_ref) |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 186 | ['server']) |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 187 | if CONF.validation.run_validation: |
| 188 | tenant_network = self.get_tenant_network() |
| 189 | compute.wait_for_ssh_or_ping( |
| 190 | server, self.os_primary, tenant_network, |
| 191 | True, self.validation_resources, "SSHABLE", True) |
| 192 | else: |
Damian Dabrowski | 5928eeb | 2022-10-27 16:13:53 +0200 | [diff] [blame] | 193 | waiters.wait_for_server_status(self.client, server['id'], |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 194 | 'ACTIVE') |
| 195 | |
Yaroslav Lobankov | fb1c364 | 2015-05-13 18:38:47 +0300 | [diff] [blame] | 196 | msg = ('Server was not rebuilt to the original image. ' |
| 197 | 'The original image: {0}. The current image: {1}' |
| 198 | .format(image_ref, rebuilt_server['image']['id'])) |
| 199 | self.assertEqual(image_ref, rebuilt_server['image']['id'], msg) |
| 200 | |
zhufl | 01512d2 | 2017-08-03 16:30:23 +0800 | [diff] [blame] | 201 | def _test_rebuild_server(self): |
Castulo J. Martinez | 0d1b63f | 2016-07-08 13:55:57 -0700 | [diff] [blame] | 202 | # Get the IPs the server has before rebuilding it |
| 203 | original_addresses = (self.client.show_server(self.server_id)['server'] |
| 204 | ['addresses']) |
Sean Dague | 4dd2c0b | 2013-01-03 17:50:28 -0500 | [diff] [blame] | 205 | # The server should be rebuilt using the provided image and data |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 206 | meta = {'rebuild': 'server'} |
zhufl | c6ce539 | 2016-08-17 14:34:37 +0800 | [diff] [blame] | 207 | new_name = data_utils.rand_name(self.__class__.__name__ + '-server') |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 208 | password = 'rebuildPassw0rd' |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 209 | rebuilt_server = self.client.rebuild_server( |
| 210 | self.server_id, |
| 211 | self.image_ref_alt, |
| 212 | name=new_name, |
| 213 | metadata=meta, |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 214 | adminPass=password)['server'] |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 215 | |
Andrea Frittoli | e804081 | 2015-04-28 14:26:35 +0100 | [diff] [blame] | 216 | # If the server was rebuilt on a different image, restore it to the |
| 217 | # original image once the test ends |
| 218 | if self.image_ref_alt != self.image_ref: |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 219 | self.addCleanup(self._rebuild_server_and_check, self.image_ref, |
| 220 | rebuilt_server) |
Andrea Frittoli | e804081 | 2015-04-28 14:26:35 +0100 | [diff] [blame] | 221 | |
Attila Fazekas | f7f34f9 | 2013-08-01 17:01:44 +0200 | [diff] [blame] | 222 | # Verify the properties in the initial response are correct |
Brian Waldon | 3bde07f | 2011-12-13 15:11:22 -0500 | [diff] [blame] | 223 | self.assertEqual(self.server_id, rebuilt_server['id']) |
Eoghan Glynn | 57c1a3d | 2012-03-01 16:50:29 -0500 | [diff] [blame] | 224 | rebuilt_image_id = rebuilt_server['image']['id'] |
| 225 | self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) |
zhufl | bcb7117 | 2018-03-29 13:49:31 +0800 | [diff] [blame] | 226 | self.assert_flavor_equal(self.flavor_ref, rebuilt_server['flavor']) |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 227 | |
Attila Fazekas | f7f34f9 | 2013-08-01 17:01:44 +0200 | [diff] [blame] | 228 | # Verify the server properties after the rebuild completes |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 229 | waiters.wait_for_server_status(self.client, |
| 230 | rebuilt_server['id'], 'ACTIVE') |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 231 | server = self.client.show_server(rebuilt_server['id'])['server'] |
Zhi Kun Liu | e540176 | 2013-09-11 20:45:48 +0800 | [diff] [blame] | 232 | rebuilt_image_id = server['image']['id'] |
Eoghan Glynn | 57c1a3d | 2012-03-01 16:50:29 -0500 | [diff] [blame] | 233 | self.assertTrue(self.image_ref_alt.endswith(rebuilt_image_id)) |
Zhi Kun Liu | e540176 | 2013-09-11 20:45:48 +0800 | [diff] [blame] | 234 | self.assertEqual(new_name, server['name']) |
Castulo J. Martinez | 0d1b63f | 2016-07-08 13:55:57 -0700 | [diff] [blame] | 235 | self.assertEqual(original_addresses, server['addresses']) |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 236 | |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 237 | if CONF.validation.run_validation: |
wangxiyuan | 878c50e | 2016-01-04 19:24:17 +0800 | [diff] [blame] | 238 | # Authentication is attempted in the following order of priority: |
| 239 | # 1.The key passed in, if one was passed in. |
| 240 | # 2.Any key we can find through an SSH agent (if allowed). |
| 241 | # 3.Any "id_rsa", "id_dsa" or "id_ecdsa" key discoverable in |
| 242 | # ~/.ssh/ (if allowed). |
| 243 | # 4.Plain username/password auth, if a password was given. |
Joseph Lanoux | ffe09dd | 2015-03-18 16:45:33 +0000 | [diff] [blame] | 244 | linux_client = remote_client.RemoteClient( |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 245 | self.get_server_ip(rebuilt_server, self.validation_resources), |
Weronika Sikora | c54a911 | 2019-09-18 13:55:07 +0000 | [diff] [blame] | 246 | self.ssh_alt_user, |
wangxiyuan | 878c50e | 2016-01-04 19:24:17 +0800 | [diff] [blame] | 247 | password, |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 248 | self.validation_resources['keypair']['private_key'], |
Andrea Frittoli (andreaf) | 2a70a61 | 2016-04-29 16:09:13 -0500 | [diff] [blame] | 249 | server=rebuilt_server, |
| 250 | servers_client=self.client) |
Attila Fazekas | ad7ef7d | 2013-11-20 10:12:53 +0100 | [diff] [blame] | 251 | linux_client.validate_authentication() |
Daryl Walleck | 98e66dd | 2012-06-21 04:58:39 -0500 | [diff] [blame] | 252 | |
zhufl | 01512d2 | 2017-08-03 16:30:23 +0800 | [diff] [blame] | 253 | @decorators.idempotent_id('aaa6cdf3-55a7-461a-add9-1c8596b9a07c') |
| 254 | def test_rebuild_server(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 255 | """Test rebuilding server |
| 256 | |
| 257 | The server should be rebuilt using the provided image and data. |
| 258 | """ |
zhufl | 01512d2 | 2017-08-03 16:30:23 +0800 | [diff] [blame] | 259 | self._test_rebuild_server() |
| 260 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 261 | @decorators.idempotent_id('30449a88-5aff-4f9b-9866-6ee9b17f906d') |
Zhi Kun Liu | e540176 | 2013-09-11 20:45:48 +0800 | [diff] [blame] | 262 | def test_rebuild_server_in_stop_state(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 263 | """Test rebuilding server in stop state |
| 264 | |
| 265 | The server in stop state should be rebuilt using the provided |
| 266 | image and remain in SHUTOFF state. |
| 267 | """ |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 268 | server = self.client.show_server(self.server_id)['server'] |
Zhi Kun Liu | e540176 | 2013-09-11 20:45:48 +0800 | [diff] [blame] | 269 | old_image = server['image']['id'] |
Yaroslav Lobankov | fb1c364 | 2015-05-13 18:38:47 +0300 | [diff] [blame] | 270 | new_image = (self.image_ref_alt |
| 271 | if old_image == self.image_ref else self.image_ref) |
Ken'ichi Ohmichi | b263108 | 2015-08-27 01:31:00 +0000 | [diff] [blame] | 272 | self.client.stop_server(self.server_id) |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 273 | waiters.wait_for_server_status(self.client, self.server_id, 'SHUTOFF') |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 274 | rebuilt_server = (self.client.rebuild_server(self.server_id, new_image) |
| 275 | ['server']) |
Yaroslav Lobankov | fb1c364 | 2015-05-13 18:38:47 +0300 | [diff] [blame] | 276 | # If the server was rebuilt on a different image, restore it to the |
| 277 | # original image once the test ends |
| 278 | if self.image_ref_alt != self.image_ref: |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 279 | self.addCleanup(self._rebuild_server_and_check, old_image, server) |
Zhi Kun Liu | e540176 | 2013-09-11 20:45:48 +0800 | [diff] [blame] | 280 | |
| 281 | # Verify the properties in the initial response are correct |
| 282 | self.assertEqual(self.server_id, rebuilt_server['id']) |
| 283 | rebuilt_image_id = rebuilt_server['image']['id'] |
| 284 | self.assertEqual(new_image, rebuilt_image_id) |
zhufl | bcb7117 | 2018-03-29 13:49:31 +0800 | [diff] [blame] | 285 | self.assert_flavor_equal(self.flavor_ref, rebuilt_server['flavor']) |
Zhi Kun Liu | e540176 | 2013-09-11 20:45:48 +0800 | [diff] [blame] | 286 | |
| 287 | # Verify the server properties after the rebuild completes |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 288 | waiters.wait_for_server_status(self.client, |
| 289 | rebuilt_server['id'], 'SHUTOFF') |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 290 | server = self.client.show_server(rebuilt_server['id'])['server'] |
Zhi Kun Liu | e540176 | 2013-09-11 20:45:48 +0800 | [diff] [blame] | 291 | rebuilt_image_id = server['image']['id'] |
| 292 | self.assertEqual(new_image, rebuilt_image_id) |
| 293 | |
Ken'ichi Ohmichi | b263108 | 2015-08-27 01:31:00 +0000 | [diff] [blame] | 294 | self.client.start_server(self.server_id) |
Attila Fazekas | 305e65b | 2013-10-29 13:23:07 +0100 | [diff] [blame] | 295 | |
Matt Riedemann | b572053 | 2018-09-19 16:02:05 -0400 | [diff] [blame] | 296 | # NOTE(mriedem): Marked as slow because while rebuild and volume-backed is |
| 297 | # common, we don't actually change the image (you can't with volume-backed |
| 298 | # rebuild) so this isn't testing much outside normal rebuild |
| 299 | # (and it's slow). |
| 300 | @decorators.attr(type='slow') |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 301 | @decorators.idempotent_id('b68bd8d6-855d-4212-b59b-2e704044dace') |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 302 | @utils.services('volume') |
Roman Podoliaka | 908f906 | 2015-04-21 16:52:20 +0300 | [diff] [blame] | 303 | def test_rebuild_server_with_volume_attached(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 304 | """Test rebuilding server with volume attached |
| 305 | |
| 306 | The volume should be attached to the instance after rebuild. |
| 307 | """ |
Roman Podoliaka | 908f906 | 2015-04-21 16:52:20 +0300 | [diff] [blame] | 308 | # create a new volume and attach it to the server |
Matt Riedemann | f1448f0 | 2016-10-01 20:03:16 -0400 | [diff] [blame] | 309 | volume = self.create_volume() |
Roman Podoliaka | 908f906 | 2015-04-21 16:52:20 +0300 | [diff] [blame] | 310 | |
Matt Riedemann | f1448f0 | 2016-10-01 20:03:16 -0400 | [diff] [blame] | 311 | server = self.client.show_server(self.server_id)['server'] |
| 312 | self.attach_volume(server, volume) |
Roman Podoliaka | 908f906 | 2015-04-21 16:52:20 +0300 | [diff] [blame] | 313 | |
| 314 | # run general rebuild test |
zhufl | 01512d2 | 2017-08-03 16:30:23 +0800 | [diff] [blame] | 315 | self._test_rebuild_server() |
Roman Podoliaka | 908f906 | 2015-04-21 16:52:20 +0300 | [diff] [blame] | 316 | |
| 317 | # make sure the volume is attached to the instance after rebuild |
| 318 | vol_after_rebuild = self.volumes_client.show_volume(volume['id']) |
| 319 | vol_after_rebuild = vol_after_rebuild['volume'] |
| 320 | self.assertEqual('in-use', vol_after_rebuild['status']) |
| 321 | self.assertEqual(self.server_id, |
| 322 | vol_after_rebuild['attachments'][0]['server_id']) |
afazekas | 5d06623 | 2019-03-25 18:35:36 +0100 | [diff] [blame] | 323 | if CONF.validation.run_validation: |
afazekas | 5d06623 | 2019-03-25 18:35:36 +0100 | [diff] [blame] | 324 | linux_client = remote_client.RemoteClient( |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 325 | self.get_server_ip(server, self.validation_resources), |
Weronika Sikora | c54a911 | 2019-09-18 13:55:07 +0000 | [diff] [blame] | 326 | self.ssh_alt_user, |
afazekas | 5d06623 | 2019-03-25 18:35:36 +0100 | [diff] [blame] | 327 | password=None, |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 328 | pkey=self.validation_resources['keypair']['private_key'], |
afazekas | 5d06623 | 2019-03-25 18:35:36 +0100 | [diff] [blame] | 329 | server=server, |
| 330 | servers_client=self.client) |
| 331 | linux_client.validate_authentication() |
Roman Podoliaka | 908f906 | 2015-04-21 16:52:20 +0300 | [diff] [blame] | 332 | |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 333 | def _test_resize_server_confirm(self, server_id, stop=False): |
Sean Dague | 4dd2c0b | 2013-01-03 17:50:28 -0500 | [diff] [blame] | 334 | # The server's RAM and disk space should be modified to that of |
| 335 | # the provided flavor |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 336 | |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 337 | if stop: |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 338 | self.client.stop_server(server_id) |
| 339 | waiters.wait_for_server_status(self.client, server_id, |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 340 | 'SHUTOFF') |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 341 | |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 342 | self.client.resize_server(server_id, self.flavor_ref_alt) |
zhufl | 045d1f5 | 2016-08-05 15:06:35 +0800 | [diff] [blame] | 343 | # NOTE(jlk): Explicitly delete the server to get a new one for later |
| 344 | # tests. Avoids resize down race issues. |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 345 | self.addCleanup(self.delete_server, server_id) |
| 346 | waiters.wait_for_server_status(self.client, server_id, |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 347 | 'VERIFY_RESIZE') |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 348 | |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 349 | self.client.confirm_resize_server(server_id) |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 350 | expected_status = 'SHUTOFF' if stop else 'ACTIVE' |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 351 | waiters.wait_for_server_status(self.client, server_id, |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 352 | expected_status) |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 353 | |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 354 | server = self.client.show_server(server_id)['server'] |
zhufl | bcb7117 | 2018-03-29 13:49:31 +0800 | [diff] [blame] | 355 | self.assert_flavor_equal(self.flavor_ref_alt, server['flavor']) |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 356 | |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 357 | if stop: |
| 358 | # NOTE(mriedem): tearDown requires the server to be started. |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 359 | self.client.start_server(server_id) |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 360 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 361 | @decorators.idempotent_id('1499262a-9328-4eda-9068-db1ac57498d2') |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 362 | @testtools.skipUnless(CONF.compute_feature_enabled.resize, |
| 363 | 'Resize not available.') |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 364 | def test_resize_server_confirm(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 365 | """Test resizing server and then confirming""" |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 366 | self._test_resize_server_confirm(self.server_id, stop=False) |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 367 | |
Matt Riedemann | 1df75ee | 2017-10-30 12:52:51 -0400 | [diff] [blame] | 368 | @decorators.idempotent_id('e6c28180-7454-4b59-b188-0257af08a63b') |
| 369 | @decorators.related_bug('1728603') |
| 370 | @testtools.skipUnless(CONF.compute_feature_enabled.resize, |
| 371 | 'Resize not available.') |
| 372 | @utils.services('volume') |
| 373 | def test_resize_volume_backed_server_confirm(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 374 | """Test resizing a volume backed server and then confirming""" |
Matt Riedemann | 1df75ee | 2017-10-30 12:52:51 -0400 | [diff] [blame] | 375 | # We have to create a new server that is volume-backed since the one |
| 376 | # from setUp is not volume-backed. |
Weronika Sikora | 9e3cc27 | 2020-02-10 10:50:53 +0000 | [diff] [blame] | 377 | kwargs = {'volume_backed': True, |
| 378 | 'wait_until': 'ACTIVE'} |
| 379 | if CONF.validation.run_validation: |
Weronika Sikora | 9e3cc27 | 2020-02-10 10:50:53 +0000 | [diff] [blame] | 380 | kwargs.update({'validatable': True, |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 381 | 'validation_resources': self.validation_resources}) |
Weronika Sikora | 9e3cc27 | 2020-02-10 10:50:53 +0000 | [diff] [blame] | 382 | server = self.create_test_server(**kwargs) |
| 383 | |
Mark Goddard | fa30d2f | 2019-09-02 14:41:02 +0100 | [diff] [blame] | 384 | # NOTE(mgoddard): Get detailed server to ensure addresses are present |
| 385 | # in fixed IP case. |
| 386 | server = self.servers_client.show_server(server['id'])['server'] |
Weronika Sikora | 9e3cc27 | 2020-02-10 10:50:53 +0000 | [diff] [blame] | 387 | |
Matt Riedemann | 1df75ee | 2017-10-30 12:52:51 -0400 | [diff] [blame] | 388 | self._test_resize_server_confirm(server['id']) |
Weronika Sikora | 9e3cc27 | 2020-02-10 10:50:53 +0000 | [diff] [blame] | 389 | |
Evgeny Antyshev | cc40091 | 2017-11-16 13:36:14 +0000 | [diff] [blame] | 390 | if CONF.compute_feature_enabled.console_output: |
| 391 | # Now do something interactive with the guest like get its console |
| 392 | # output; we don't actually care about the output, |
| 393 | # just that it doesn't raise an error. |
| 394 | self.client.get_console_output(server['id']) |
| 395 | if CONF.validation.run_validation: |
Evgeny Antyshev | cc40091 | 2017-11-16 13:36:14 +0000 | [diff] [blame] | 396 | linux_client = remote_client.RemoteClient( |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 397 | self.get_server_ip(server, self.validation_resources), |
Evgeny Antyshev | cc40091 | 2017-11-16 13:36:14 +0000 | [diff] [blame] | 398 | self.ssh_user, |
| 399 | password=None, |
Benny Kopilov | d1d5821 | 2022-08-19 00:47:44 +0300 | [diff] [blame] | 400 | pkey=self.validation_resources['keypair']['private_key'], |
Evgeny Antyshev | cc40091 | 2017-11-16 13:36:14 +0000 | [diff] [blame] | 401 | server=server, |
| 402 | servers_client=self.client) |
| 403 | linux_client.validate_authentication() |
Matt Riedemann | 1df75ee | 2017-10-30 12:52:51 -0400 | [diff] [blame] | 404 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 405 | @decorators.idempotent_id('138b131d-66df-48c9-a171-64f45eb92962') |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 406 | @testtools.skipUnless(CONF.compute_feature_enabled.resize, |
| 407 | 'Resize not available.') |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 408 | def test_resize_server_confirm_from_stopped(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 409 | """Test resizing a stopped server and then confirming""" |
Matt Riedemann | ced8d3c | 2017-11-01 11:39:11 -0400 | [diff] [blame] | 410 | self._test_resize_server_confirm(self.server_id, stop=True) |
Matt Riedemann | 9fd63b8 | 2014-04-14 09:33:05 -0700 | [diff] [blame] | 411 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 412 | @decorators.idempotent_id('c03aab19-adb1-44f5-917d-c419577e9e68') |
Matt Riedemann | 5d1f8b1 | 2014-03-24 09:12:53 -0700 | [diff] [blame] | 413 | @testtools.skipUnless(CONF.compute_feature_enabled.resize, |
| 414 | 'Resize not available.') |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 415 | def test_resize_server_revert(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 416 | """Test resizing server and then reverting |
| 417 | |
| 418 | The server's RAM and disk space should return to its original |
| 419 | values after a resize is reverted. |
| 420 | """ |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 421 | |
Ken'ichi Ohmichi | 5271b0f | 2015-08-10 07:53:27 +0000 | [diff] [blame] | 422 | self.client.resize_server(self.server_id, self.flavor_ref_alt) |
zhufl | 045d1f5 | 2016-08-05 15:06:35 +0800 | [diff] [blame] | 423 | # NOTE(zhufl): Explicitly delete the server to get a new one for later |
| 424 | # tests. Avoids resize down race issues. |
| 425 | self.addCleanup(self.delete_server, self.server_id) |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 426 | waiters.wait_for_server_status(self.client, self.server_id, |
| 427 | 'VERIFY_RESIZE') |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 428 | |
Ken'ichi Ohmichi | b263108 | 2015-08-27 01:31:00 +0000 | [diff] [blame] | 429 | self.client.revert_resize_server(self.server_id) |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 430 | waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE') |
Daryl Walleck | ed8bef3 | 2011-12-05 23:02:08 -0600 | [diff] [blame] | 431 | |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 432 | server = self.client.show_server(self.server_id)['server'] |
zhufl | bcb7117 | 2018-03-29 13:49:31 +0800 | [diff] [blame] | 433 | self.assert_flavor_equal(self.flavor_ref, server['flavor']) |
sapan-kona | f1e3f00 | 2011-12-22 23:18:44 +0530 | [diff] [blame] | 434 | |
Matt Riedemann | 01ff7c6 | 2017-12-12 10:46:57 -0500 | [diff] [blame] | 435 | @decorators.idempotent_id('fbbf075f-a812-4022-bc5c-ccb8047eef12') |
ghanshyam | e027dd3 | 2018-07-03 05:44:27 +0000 | [diff] [blame] | 436 | @decorators.related_bug('1737599') |
Matt Riedemann | 01ff7c6 | 2017-12-12 10:46:57 -0500 | [diff] [blame] | 437 | @testtools.skipUnless(CONF.compute_feature_enabled.resize, |
| 438 | 'Resize not available.') |
| 439 | @utils.services('volume') |
| 440 | def test_resize_server_revert_with_volume_attached(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 441 | """Test resizing a volume attached server and then reverting |
| 442 | |
| 443 | Tests attaching a volume to a server instance and then resizing |
| 444 | the instance. Once the instance is resized, revert the resize which |
| 445 | should move the instance and volume attachment back to the original |
| 446 | compute host. |
| 447 | """ |
Matt Riedemann | 01ff7c6 | 2017-12-12 10:46:57 -0500 | [diff] [blame] | 448 | |
| 449 | # Create a blank volume and attach it to the server created in setUp. |
| 450 | volume = self.create_volume() |
| 451 | server = self.client.show_server(self.server_id)['server'] |
| 452 | self.attach_volume(server, volume) |
| 453 | # Now resize the server with the blank volume attached. |
| 454 | self.client.resize_server(self.server_id, self.flavor_ref_alt) |
| 455 | # Explicitly delete the server to get a new one for later |
| 456 | # tests. Avoids resize down race issues. |
| 457 | self.addCleanup(self.delete_server, self.server_id) |
| 458 | waiters.wait_for_server_status( |
| 459 | self.client, self.server_id, 'VERIFY_RESIZE') |
| 460 | # Now revert the resize which should move the instance and it's volume |
| 461 | # attachment back to the original source compute host. |
| 462 | self.client.revert_resize_server(self.server_id) |
| 463 | waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE') |
| 464 | # Make sure everything still looks OK. |
| 465 | server = self.client.show_server(self.server_id)['server'] |
zhufl | 83f524a | 2019-06-26 17:26:13 +0800 | [diff] [blame] | 466 | self.assert_flavor_equal(self.flavor_ref, server['flavor']) |
Matt Riedemann | 01ff7c6 | 2017-12-12 10:46:57 -0500 | [diff] [blame] | 467 | attached_volumes = server['os-extended-volumes:volumes_attached'] |
| 468 | self.assertEqual(1, len(attached_volumes)) |
| 469 | self.assertEqual(volume['id'], attached_volumes[0]['id']) |
| 470 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 471 | @decorators.idempotent_id('b963d4f1-94b3-4c40-9e97-7b583f46e470') |
Adam Gandelman | fbc95ac | 2014-06-19 17:33:43 -0700 | [diff] [blame] | 472 | @testtools.skipUnless(CONF.compute_feature_enabled.snapshot, |
| 473 | 'Snapshotting not available, backup not possible.') |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 474 | @utils.services('image') |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 475 | def test_create_backup(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 476 | """Test creating server backup |
| 477 | |
| 478 | 1. create server backup1 with rotation=2, there are 1 backup. |
| 479 | 2. create server backup2 with rotation=2, there are 2 backups. |
| 480 | 3. create server backup3, due to the rotation is 2, the first one |
| 481 | (backup1) will be deleted, so now there are still 2 backups. |
| 482 | """ |
| 483 | |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 484 | # create the first and the second backup |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 485 | |
| 486 | # Check if glance v1 is available to determine which client to use. We |
| 487 | # prefer glance v1 for the compute API tests since the compute image |
| 488 | # API proxy was written for glance v1. |
| 489 | if CONF.image_feature_enabled.api_v1: |
Jordan Pittier | 8160d31 | 2017-04-18 11:52:23 +0200 | [diff] [blame] | 490 | glance_client = self.os_primary.image_client |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 491 | elif CONF.image_feature_enabled.api_v2: |
Jordan Pittier | 8160d31 | 2017-04-18 11:52:23 +0200 | [diff] [blame] | 492 | glance_client = self.os_primary.image_client_v2 |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 493 | else: |
Matthew Treinish | 4217a70 | 2016-10-07 17:27:11 -0400 | [diff] [blame] | 494 | raise lib_exc.InvalidConfiguration( |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 495 | 'Either api_v1 or api_v2 must be True in ' |
| 496 | '[image-feature-enabled].') |
| 497 | |
Matt Riedemann | e699f82 | 2014-01-24 08:11:42 -0800 | [diff] [blame] | 498 | backup1 = data_utils.rand_name('backup-1') |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 499 | resp = self.client.create_backup(self.server_id, |
Ken'ichi Ohmichi | e6349f3 | 2015-12-09 06:47:54 +0000 | [diff] [blame] | 500 | backup_type='daily', |
| 501 | rotation=2, |
zhufl | 2856ad5 | 2018-03-29 11:06:34 +0800 | [diff] [blame] | 502 | name=backup1) |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 503 | oldest_backup_exist = True |
| 504 | |
| 505 | # the oldest one should be deleted automatically in this test |
| 506 | def _clean_oldest_backup(oldest_backup): |
| 507 | if oldest_backup_exist: |
Ryan Hsu | 3823109 | 2014-06-08 23:12:10 -0700 | [diff] [blame] | 508 | try: |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 509 | glance_client.delete_image(oldest_backup) |
Masayuki Igawa | bfa0760 | 2015-01-20 18:47:17 +0900 | [diff] [blame] | 510 | except lib_exc.NotFound: |
Ryan Hsu | 3823109 | 2014-06-08 23:12:10 -0700 | [diff] [blame] | 511 | pass |
| 512 | else: |
| 513 | LOG.warning("Deletion of oldest backup %s should not have " |
| 514 | "been successful as it should have been " |
Jordan Pittier | 525ec71 | 2016-12-07 17:51:26 +0100 | [diff] [blame] | 515 | "deleted during rotation.", oldest_backup) |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 516 | |
Felipe Monteiro | 9ff5c28 | 2017-06-21 21:05:07 +0100 | [diff] [blame] | 517 | if api_version_utils.compare_version_header_to_response( |
zhufl | 2856ad5 | 2018-03-29 11:06:34 +0800 | [diff] [blame] | 518 | "OpenStack-API-Version", "compute 2.45", resp.response, "lt"): |
Felipe Monteiro | 9ff5c28 | 2017-06-21 21:05:07 +0100 | [diff] [blame] | 519 | image1_id = resp['image_id'] |
| 520 | else: |
zhufl | 2856ad5 | 2018-03-29 11:06:34 +0800 | [diff] [blame] | 521 | image1_id = data_utils.parse_image_id(resp.response['location']) |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 522 | self.addCleanup(_clean_oldest_backup, image1_id) |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 523 | waiters.wait_for_image_status(glance_client, |
Yaroslav Lobankov | 2fea405 | 2016-04-19 15:05:57 +0300 | [diff] [blame] | 524 | image1_id, 'active') |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 525 | |
Matt Riedemann | e699f82 | 2014-01-24 08:11:42 -0800 | [diff] [blame] | 526 | backup2 = data_utils.rand_name('backup-2') |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 527 | waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE') |
| 528 | resp = self.client.create_backup(self.server_id, |
Ken'ichi Ohmichi | e6349f3 | 2015-12-09 06:47:54 +0000 | [diff] [blame] | 529 | backup_type='daily', |
| 530 | rotation=2, |
zhufl | 2856ad5 | 2018-03-29 11:06:34 +0800 | [diff] [blame] | 531 | name=backup2) |
Felipe Monteiro | 9ff5c28 | 2017-06-21 21:05:07 +0100 | [diff] [blame] | 532 | if api_version_utils.compare_version_header_to_response( |
zhufl | 2856ad5 | 2018-03-29 11:06:34 +0800 | [diff] [blame] | 533 | "OpenStack-API-Version", "compute 2.45", resp.response, "lt"): |
Felipe Monteiro | 9ff5c28 | 2017-06-21 21:05:07 +0100 | [diff] [blame] | 534 | image2_id = resp['image_id'] |
| 535 | else: |
zhufl | 2856ad5 | 2018-03-29 11:06:34 +0800 | [diff] [blame] | 536 | image2_id = data_utils.parse_image_id(resp.response['location']) |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 537 | self.addCleanup(glance_client.delete_image, image2_id) |
| 538 | waiters.wait_for_image_status(glance_client, |
Yaroslav Lobankov | 2fea405 | 2016-04-19 15:05:57 +0300 | [diff] [blame] | 539 | image2_id, 'active') |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 540 | |
| 541 | # verify they have been created |
| 542 | properties = { |
| 543 | 'image_type': 'backup', |
| 544 | 'backup_type': "daily", |
| 545 | 'instance_uuid': self.server_id, |
| 546 | } |
Ken'ichi Ohmichi | 45d7d42 | 2016-06-22 10:03:28 -0700 | [diff] [blame] | 547 | params = { |
| 548 | 'status': 'active', |
| 549 | 'sort_key': 'created_at', |
| 550 | 'sort_dir': 'asc' |
| 551 | } |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 552 | if CONF.image_feature_enabled.api_v1: |
Ken'ichi Ohmichi | e28b2c2 | 2016-06-22 10:07:27 -0700 | [diff] [blame] | 553 | for key, value in properties.items(): |
| 554 | params['property-%s' % key] = value |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 555 | image_list = glance_client.list_images( |
| 556 | detail=True, |
| 557 | **params)['images'] |
| 558 | else: |
| 559 | # Additional properties are flattened in glance v2. |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 560 | params.update(properties) |
| 561 | image_list = glance_client.list_images(params)['images'] |
| 562 | |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 563 | self.assertEqual(2, len(image_list)) |
| 564 | self.assertEqual((backup1, backup2), |
| 565 | (image_list[0]['name'], image_list[1]['name'])) |
| 566 | |
| 567 | # create the third one, due to the rotation is 2, |
| 568 | # the first one will be deleted |
Matt Riedemann | e699f82 | 2014-01-24 08:11:42 -0800 | [diff] [blame] | 569 | backup3 = data_utils.rand_name('backup-3') |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 570 | waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE') |
| 571 | resp = self.client.create_backup(self.server_id, |
Ken'ichi Ohmichi | e6349f3 | 2015-12-09 06:47:54 +0000 | [diff] [blame] | 572 | backup_type='daily', |
| 573 | rotation=2, |
zhufl | 2856ad5 | 2018-03-29 11:06:34 +0800 | [diff] [blame] | 574 | name=backup3) |
Felipe Monteiro | 9ff5c28 | 2017-06-21 21:05:07 +0100 | [diff] [blame] | 575 | if api_version_utils.compare_version_header_to_response( |
zhufl | 2856ad5 | 2018-03-29 11:06:34 +0800 | [diff] [blame] | 576 | "OpenStack-API-Version", "compute 2.45", resp.response, "lt"): |
Felipe Monteiro | 9ff5c28 | 2017-06-21 21:05:07 +0100 | [diff] [blame] | 577 | image3_id = resp['image_id'] |
| 578 | else: |
zhufl | 2856ad5 | 2018-03-29 11:06:34 +0800 | [diff] [blame] | 579 | image3_id = data_utils.parse_image_id(resp.response['location']) |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 580 | self.addCleanup(glance_client.delete_image, image3_id) |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 581 | # the first back up should be deleted |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 582 | waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE') |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 583 | glance_client.wait_for_resource_deletion(image1_id) |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 584 | oldest_backup_exist = False |
Matt Riedemann | 2aa19d4 | 2016-06-06 17:45:41 -0400 | [diff] [blame] | 585 | if CONF.image_feature_enabled.api_v1: |
| 586 | image_list = glance_client.list_images( |
| 587 | detail=True, **params)['images'] |
| 588 | else: |
| 589 | image_list = glance_client.list_images(params)['images'] |
Matt Riedemann | e699f82 | 2014-01-24 08:11:42 -0800 | [diff] [blame] | 590 | self.assertEqual(2, len(image_list), |
| 591 | 'Unexpected number of images for ' |
| 592 | 'v2:test_create_backup; was the oldest backup not ' |
| 593 | 'yet deleted? Image list: %s' % |
| 594 | [image['name'] for image in image_list]) |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 595 | self.assertEqual((backup2, backup3), |
| 596 | (image_list[0]['name'], image_list[1]['name'])) |
| 597 | |
Ken'ichi Ohmichi | 547a306 | 2013-12-02 09:30:36 +0900 | [diff] [blame] | 598 | def _get_output(self): |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 599 | output = self.client.get_console_output( |
zhufl | 15140ee | 2018-07-25 16:26:21 +0800 | [diff] [blame] | 600 | self.server_id, length=3)['output'] |
Ken'ichi Ohmichi | 547a306 | 2013-12-02 09:30:36 +0900 | [diff] [blame] | 601 | self.assertTrue(output, "Console output was empty.") |
| 602 | lines = len(output.split('\n')) |
zhufl | 15140ee | 2018-07-25 16:26:21 +0800 | [diff] [blame] | 603 | self.assertEqual(lines, 3) |
Ken'ichi Ohmichi | 547a306 | 2013-12-02 09:30:36 +0900 | [diff] [blame] | 604 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 605 | @decorators.idempotent_id('4b8867e6-fffa-4d54-b1d1-6fdda57be2f3') |
Adam Gandelman | c6eefb4 | 2014-07-15 16:44:08 -0700 | [diff] [blame] | 606 | @testtools.skipUnless(CONF.compute_feature_enabled.console_output, |
| 607 | 'Console output not supported.') |
Attila Fazekas | 45c3fbc | 2013-02-24 16:39:52 +0100 | [diff] [blame] | 608 | def test_get_console_output(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 609 | """Test getting console output for a server |
| 610 | |
| 611 | Should be able to GET the console output for a given server_id and |
| 612 | number of lines. |
| 613 | """ |
Ken'ichi Ohmichi | 851a135 | 2013-11-26 18:42:52 +0900 | [diff] [blame] | 614 | |
| 615 | # This reboot is necessary for outputting some console log after |
Takashi NATSUME | 6d5a2b4 | 2015-09-08 11:27:49 +0900 | [diff] [blame] | 616 | # creating an instance backup. If an instance backup, the console |
Ken'ichi Ohmichi | 851a135 | 2013-11-26 18:42:52 +0900 | [diff] [blame] | 617 | # log file is truncated and we cannot get any console log through |
| 618 | # "console-log" API. |
| 619 | # The detail is https://bugs.launchpad.net/nova/+bug/1251920 |
Artom Lifshitz | ea2b59c | 2021-08-19 14:34:00 -0400 | [diff] [blame] | 620 | self.reboot_server(self.server_id, type='HARD') |
Ken'ichi Ohmichi | 547a306 | 2013-12-02 09:30:36 +0900 | [diff] [blame] | 621 | self.wait_for(self._get_output) |
Attila Fazekas | 45c3fbc | 2013-02-24 16:39:52 +0100 | [diff] [blame] | 622 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 623 | @decorators.idempotent_id('89104062-69d8-4b19-a71b-f47b7af093d7') |
Adam Gandelman | c6eefb4 | 2014-07-15 16:44:08 -0700 | [diff] [blame] | 624 | @testtools.skipUnless(CONF.compute_feature_enabled.console_output, |
| 625 | 'Console output not supported.') |
Ken'ichi Ohmichi | bd5df12 | 2014-09-18 08:03:52 +0000 | [diff] [blame] | 626 | def test_get_console_output_with_unlimited_size(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 627 | """Test getting server's console output with unlimited size |
| 628 | |
| 629 | The console output lines length should be bigger than the one |
| 630 | of test_get_console_output. |
| 631 | """ |
David Kranz | 0fb1429 | 2015-02-11 15:55:20 -0500 | [diff] [blame] | 632 | server = self.create_test_server(wait_until='ACTIVE') |
Ken'ichi Ohmichi | bd5df12 | 2014-09-18 08:03:52 +0000 | [diff] [blame] | 633 | |
| 634 | def _check_full_length_console_log(): |
Ken'ichi Ohmichi | bf4766a | 2015-12-09 07:48:43 +0000 | [diff] [blame] | 635 | output = self.client.get_console_output(server['id'])['output'] |
Ken'ichi Ohmichi | bd5df12 | 2014-09-18 08:03:52 +0000 | [diff] [blame] | 636 | self.assertTrue(output, "Console output was empty.") |
| 637 | lines = len(output.split('\n')) |
| 638 | |
| 639 | # NOTE: This test tries to get full length console log, and the |
| 640 | # length should be bigger than the one of test_get_console_output. |
zhufl | 15140ee | 2018-07-25 16:26:21 +0800 | [diff] [blame] | 641 | self.assertGreater(lines, 3, "Cannot get enough console log " |
| 642 | "length. (lines: %s)" % lines) |
Ken'ichi Ohmichi | bd5df12 | 2014-09-18 08:03:52 +0000 | [diff] [blame] | 643 | |
| 644 | self.wait_for(_check_full_length_console_log) |
| 645 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 646 | @decorators.idempotent_id('5b65d4e7-4ecd-437c-83c0-d6b79d927568') |
Ken'ichi Ohmichi | bd5df12 | 2014-09-18 08:03:52 +0000 | [diff] [blame] | 647 | @testtools.skipUnless(CONF.compute_feature_enabled.console_output, |
| 648 | 'Console output not supported.') |
Ken'ichi Ohmichi | 547a306 | 2013-12-02 09:30:36 +0900 | [diff] [blame] | 649 | def test_get_console_output_server_id_in_shutoff_status(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 650 | """Test getting console output for a server in SHUTOFF status |
| 651 | |
| 652 | Should be able to GET the console output for a given server_id |
| 653 | in SHUTOFF status. |
| 654 | """ |
Ken'ichi Ohmichi | 547a306 | 2013-12-02 09:30:36 +0900 | [diff] [blame] | 655 | |
| 656 | # NOTE: SHUTOFF is irregular status. To avoid test instability, |
| 657 | # one server is created only for this test without using |
Ken'ichi Ohmichi | 4d8ba23 | 2017-03-03 18:28:05 -0800 | [diff] [blame] | 658 | # the server that was created in setUpClass. |
David Kranz | 0fb1429 | 2015-02-11 15:55:20 -0500 | [diff] [blame] | 659 | server = self.create_test_server(wait_until='ACTIVE') |
Ken'ichi Ohmichi | 547a306 | 2013-12-02 09:30:36 +0900 | [diff] [blame] | 660 | temp_server_id = server['id'] |
| 661 | |
Ken'ichi Ohmichi | b263108 | 2015-08-27 01:31:00 +0000 | [diff] [blame] | 662 | self.client.stop_server(temp_server_id) |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 663 | waiters.wait_for_server_status(self.client, temp_server_id, 'SHUTOFF') |
Ken'ichi Ohmichi | 547a306 | 2013-12-02 09:30:36 +0900 | [diff] [blame] | 664 | self.wait_for(self._get_output) |
Dan Smith | bc3bd24 | 2012-08-14 09:48:48 -0700 | [diff] [blame] | 665 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 666 | @decorators.idempotent_id('bd61a9fd-062f-4670-972b-2d6c3e3b9e73') |
Matt Riedemann | 992162e | 2014-03-24 09:11:06 -0700 | [diff] [blame] | 667 | @testtools.skipUnless(CONF.compute_feature_enabled.pause, |
| 668 | 'Pause is not available.') |
Prem Karat | 6631f80 | 2013-07-04 12:07:33 +0530 | [diff] [blame] | 669 | def test_pause_unpause_server(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 670 | """Test pausing and unpausing server""" |
David Kranz | ae99b9a | 2015-02-16 13:37:01 -0500 | [diff] [blame] | 671 | self.client.pause_server(self.server_id) |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 672 | waiters.wait_for_server_status(self.client, self.server_id, 'PAUSED') |
David Kranz | ae99b9a | 2015-02-16 13:37:01 -0500 | [diff] [blame] | 673 | self.client.unpause_server(self.server_id) |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 674 | waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE') |
Prem Karat | 6631f80 | 2013-07-04 12:07:33 +0530 | [diff] [blame] | 675 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 676 | @decorators.idempotent_id('0d8ee21e-b749-462d-83da-b85b41c86c7f') |
Matt Riedemann | f0cf695 | 2014-03-24 09:08:52 -0700 | [diff] [blame] | 677 | @testtools.skipUnless(CONF.compute_feature_enabled.suspend, |
| 678 | 'Suspend is not available.') |
Prem Karat | 6631f80 | 2013-07-04 12:07:33 +0530 | [diff] [blame] | 679 | def test_suspend_resume_server(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 680 | """Test suspending and resuming server""" |
David Kranz | ae99b9a | 2015-02-16 13:37:01 -0500 | [diff] [blame] | 681 | self.client.suspend_server(self.server_id) |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 682 | waiters.wait_for_server_status(self.client, self.server_id, |
| 683 | 'SUSPENDED') |
David Kranz | ae99b9a | 2015-02-16 13:37:01 -0500 | [diff] [blame] | 684 | self.client.resume_server(self.server_id) |
Ken'ichi Ohmichi | 0eb153c | 2015-07-13 02:18:25 +0000 | [diff] [blame] | 685 | waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE') |
Prem Karat | 6631f80 | 2013-07-04 12:07:33 +0530 | [diff] [blame] | 686 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 687 | @decorators.idempotent_id('77eba8e0-036e-4635-944b-f7a8f3b78dc9') |
David Shrewsbury | 25f666f | 2014-07-22 12:17:59 -0400 | [diff] [blame] | 688 | @testtools.skipUnless(CONF.compute_feature_enabled.shelve, |
| 689 | 'Shelve is not available.') |
Andrea Frittoli | cd36841 | 2017-08-14 21:37:56 +0100 | [diff] [blame] | 690 | @utils.services('image') |
Ken'ichi Ohmichi | 39437e2 | 2013-10-06 00:21:38 +0900 | [diff] [blame] | 691 | def test_shelve_unshelve_server(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 692 | """Test shelving and unshelving server""" |
ghanshyam | 43a4065 | 2017-06-27 11:23:27 +0300 | [diff] [blame] | 693 | if CONF.image_feature_enabled.api_v2: |
| 694 | glance_client = self.os_primary.image_client_v2 |
| 695 | elif CONF.image_feature_enabled.api_v1: |
| 696 | glance_client = self.os_primary.image_client |
| 697 | else: |
| 698 | raise lib_exc.InvalidConfiguration( |
| 699 | 'Either api_v1 or api_v2 must be True in ' |
| 700 | '[image-feature-enabled].') |
ghanshyam | 017b5fe | 2016-04-15 18:49:26 +0900 | [diff] [blame] | 701 | compute.shelve_server(self.client, self.server_id, |
| 702 | force_shelve_offload=True) |
Ken'ichi Ohmichi | 17b7f11 | 2014-02-20 06:33:49 +0900 | [diff] [blame] | 703 | |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 704 | server = self.client.show_server(self.server_id)['server'] |
Ken'ichi Ohmichi | 39437e2 | 2013-10-06 00:21:38 +0900 | [diff] [blame] | 705 | image_name = server['name'] + '-shelved' |
| 706 | params = {'name': image_name} |
ghanshyam | 43a4065 | 2017-06-27 11:23:27 +0300 | [diff] [blame] | 707 | if CONF.image_feature_enabled.api_v2: |
| 708 | images = glance_client.list_images(params)['images'] |
| 709 | elif CONF.image_feature_enabled.api_v1: |
| 710 | images = glance_client.list_images( |
| 711 | detail=True, **params)['images'] |
Ken'ichi Ohmichi | 39437e2 | 2013-10-06 00:21:38 +0900 | [diff] [blame] | 712 | self.assertEqual(1, len(images)) |
| 713 | self.assertEqual(image_name, images[0]['name']) |
| 714 | |
René Ribaud | be79b46 | 2023-05-10 14:30:10 +0200 | [diff] [blame] | 715 | body = self.client.unshelve_server(self.server_id) |
| 716 | waiters.wait_for_server_status( |
| 717 | self.client, |
| 718 | self.server_id, |
| 719 | "ACTIVE", |
| 720 | request_id=body.response["x-openstack-request-id"], |
| 721 | ) |
ghanshyam | 43a4065 | 2017-06-27 11:23:27 +0300 | [diff] [blame] | 722 | glance_client.wait_for_resource_deletion(images[0]['id']) |
rsritesh | 8fdfb1c | 2017-05-08 11:14:00 +0530 | [diff] [blame] | 723 | |
ghanshyam | a90ade0 | 2018-04-25 08:16:08 +0000 | [diff] [blame] | 724 | @decorators.idempotent_id('8cf9f450-a871-42cf-9bef-77eba189c0b0') |
| 725 | @decorators.related_bug('1745529') |
| 726 | @testtools.skipUnless(CONF.compute_feature_enabled.shelve, |
| 727 | 'Shelve is not available.') |
| 728 | @testtools.skipUnless(CONF.compute_feature_enabled.pause, |
| 729 | 'Pause is not available.') |
| 730 | def test_shelve_paused_server(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 731 | """Test shelving a paused server""" |
ghanshyam | a90ade0 | 2018-04-25 08:16:08 +0000 | [diff] [blame] | 732 | server = self.create_test_server(wait_until='ACTIVE') |
| 733 | self.client.pause_server(server['id']) |
| 734 | waiters.wait_for_server_status(self.client, server['id'], 'PAUSED') |
| 735 | # Check if Shelve operation is successful on paused server. |
| 736 | compute.shelve_server(self.client, server['id'], |
| 737 | force_shelve_offload=True) |
| 738 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 739 | @decorators.idempotent_id('af8eafd4-38a7-4a4b-bdbc-75145a580560') |
Anju Tiwari | af98d22 | 2013-08-05 15:19:50 +0530 | [diff] [blame] | 740 | def test_stop_start_server(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 741 | """Test stopping and starting server""" |
Ken'ichi Ohmichi | b263108 | 2015-08-27 01:31:00 +0000 | [diff] [blame] | 742 | self.client.stop_server(self.server_id) |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 743 | waiters.wait_for_server_status(self.client, self.server_id, 'SHUTOFF') |
Ken'ichi Ohmichi | b263108 | 2015-08-27 01:31:00 +0000 | [diff] [blame] | 744 | self.client.start_server(self.server_id) |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 745 | waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE') |
Anju Tiwari | af98d22 | 2013-08-05 15:19:50 +0530 | [diff] [blame] | 746 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 747 | @decorators.idempotent_id('80a8094c-211e-440a-ab88-9e59d556c7ee') |
Zhu Zhu | 9643e51 | 2013-09-23 09:13:07 -0500 | [diff] [blame] | 748 | def test_lock_unlock_server(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 749 | """Test locking and unlocking server |
| 750 | |
| 751 | Lock the server, and trying to stop it will fail because locked |
| 752 | server is not allowed to be stopped by non-admin user. |
| 753 | Then unlock the server, now the server can be stopped and started. |
| 754 | """ |
Zhu Zhu | 9643e51 | 2013-09-23 09:13:07 -0500 | [diff] [blame] | 755 | # Lock the server,try server stop(exceptions throw),unlock it and retry |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 756 | self.client.lock_server(self.server_id) |
Viktor Tikkanen | 3d063df | 2015-06-26 07:55:11 +0300 | [diff] [blame] | 757 | self.addCleanup(self.client.unlock_server, self.server_id) |
ghanshyam | 0f82525 | 2015-08-25 16:02:50 +0900 | [diff] [blame] | 758 | server = self.client.show_server(self.server_id)['server'] |
Zhu Zhu | 9643e51 | 2013-09-23 09:13:07 -0500 | [diff] [blame] | 759 | self.assertEqual(server['status'], 'ACTIVE') |
| 760 | # Locked server is not allowed to be stopped by non-admin user |
Masayuki Igawa | d938876 | 2015-01-20 14:56:42 +0900 | [diff] [blame] | 761 | self.assertRaises(lib_exc.Conflict, |
Ken'ichi Ohmichi | b263108 | 2015-08-27 01:31:00 +0000 | [diff] [blame] | 762 | self.client.stop_server, self.server_id) |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 763 | self.client.unlock_server(self.server_id) |
Ken'ichi Ohmichi | b263108 | 2015-08-27 01:31:00 +0000 | [diff] [blame] | 764 | self.client.stop_server(self.server_id) |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 765 | waiters.wait_for_server_status(self.client, self.server_id, 'SHUTOFF') |
Ken'ichi Ohmichi | b263108 | 2015-08-27 01:31:00 +0000 | [diff] [blame] | 766 | self.client.start_server(self.server_id) |
Ken'ichi Ohmichi | 32752ff | 2015-07-13 04:33:23 +0000 | [diff] [blame] | 767 | waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE') |
Zhu Zhu | 9643e51 | 2013-09-23 09:13:07 -0500 | [diff] [blame] | 768 | |
Ghanshyam | 86d1a57 | 2014-03-05 10:19:25 +0900 | [diff] [blame] | 769 | def _validate_url(self, url): |
| 770 | valid_scheme = ['http', 'https'] |
| 771 | parsed_url = urlparse.urlparse(url) |
| 772 | self.assertNotEqual('None', parsed_url.port) |
| 773 | self.assertNotEqual('None', parsed_url.hostname) |
| 774 | self.assertIn(parsed_url.scheme, valid_scheme) |
| 775 | |
Ken'ichi Ohmichi | 14b0ae1 | 2017-01-27 17:18:52 -0800 | [diff] [blame] | 776 | @decorators.idempotent_id('c6bc11bf-592e-4015-9319-1c98dc64daf5') |
Ghanshyam | 86d1a57 | 2014-03-05 10:19:25 +0900 | [diff] [blame] | 777 | @testtools.skipUnless(CONF.compute_feature_enabled.vnc_console, |
| 778 | 'VNC Console feature is disabled.') |
Ghanshyam | 86d1a57 | 2014-03-05 10:19:25 +0900 | [diff] [blame] | 779 | def test_get_vnc_console(self): |
zhufl | 27f410a | 2020-08-13 15:27:59 +0800 | [diff] [blame] | 780 | """Test getting vnc console from a server |
| 781 | |
| 782 | The returned vnc console url should be in valid format. |
| 783 | """ |
Lee Yarwood | 8a64909 | 2019-11-25 08:37:54 +0000 | [diff] [blame] | 784 | if self.is_requested_microversion_compatible('2.5'): |
| 785 | body = self.client.get_vnc_console( |
| 786 | self.server_id, type='novnc')['console'] |
| 787 | else: |
| 788 | body = self.client.get_remote_console( |
| 789 | self.server_id, console_type='novnc', |
| 790 | protocol='vnc')['remote_console'] |
| 791 | self.assertEqual('novnc', body['type']) |
| 792 | self.assertNotEqual('', body['url']) |
| 793 | self._validate_url(body['url']) |
Ghanshyam Mann | 3ee9f21 | 2021-12-16 16:55:14 -0600 | [diff] [blame] | 794 | |
| 795 | |
| 796 | class ServersAaction247Test(base.BaseV2ComputeTest): |
| 797 | """Test compute server with microversion greater than 2.47 |
| 798 | |
| 799 | # NOTE(gmann): This test tests the Server create backup APIs |
| 800 | # response schema for 2.47 microversion. No specific assert |
| 801 | # or behaviour verification is needed. |
| 802 | """ |
| 803 | |
| 804 | min_microversion = '2.47' |
| 805 | |
| 806 | @testtools.skipUnless(CONF.compute_feature_enabled.snapshot, |
| 807 | 'Snapshotting not available, backup not possible.') |
| 808 | @utils.services('image') |
| 809 | @decorators.idempotent_id('252a4bdd-6366-4dae-9994-8c30aa660f23') |
| 810 | def test_create_backup(self): |
| 811 | server = self.create_test_server(wait_until='ACTIVE') |
| 812 | |
| 813 | backup1 = data_utils.rand_name('backup-1') |
| 814 | # Just check create_back to verify the schema with 2.47 |
| 815 | self.servers_client.create_backup(server['id'], |
| 816 | backup_type='daily', |
| 817 | rotation=2, |
| 818 | name=backup1) |
whoami-rajat | 768d253 | 2022-02-26 00:16:35 +0530 | [diff] [blame] | 819 | |
| 820 | |
| 821 | class ServerActionsV293TestJSON(base.BaseV2ComputeTest): |
| 822 | |
| 823 | min_microversion = '2.93' |
| 824 | volume_min_microversion = '3.68' |
| 825 | |
| 826 | @classmethod |
| 827 | def setup_credentials(cls): |
| 828 | cls.prepare_instance_network() |
| 829 | super(ServerActionsV293TestJSON, cls).setup_credentials() |
| 830 | |
| 831 | @classmethod |
| 832 | def resource_setup(cls): |
| 833 | super(ServerActionsV293TestJSON, cls).resource_setup() |
| 834 | cls.server_id = cls.recreate_server(None, validatable=True) |
| 835 | |
| 836 | @utils.services('volume') |
| 837 | @decorators.idempotent_id('6652dab9-ea24-4c93-ab5a-93d79c3041cf') |
| 838 | def test_rebuild_volume_backed_server(self): |
| 839 | """Test rebuilding a volume backed server""" |
| 840 | # We have to create a new server that is volume-backed since the one |
| 841 | # from setUp is not volume-backed. |
| 842 | kwargs = {'volume_backed': True, |
| 843 | 'wait_until': 'ACTIVE'} |
| 844 | validation_resources = {} |
| 845 | if CONF.validation.run_validation: |
| 846 | validation_resources = self.get_test_validation_resources( |
| 847 | self.os_primary) |
| 848 | kwargs.update({'validatable': True, |
| 849 | 'validation_resources': validation_resources}) |
| 850 | server = self.create_test_server(**kwargs) |
| 851 | server = self.servers_client.show_server(server['id'])['server'] |
| 852 | self.addCleanup(self.delete_server, server['id']) |
| 853 | volume_id = server['os-extended-volumes:volumes_attached'][0]['id'] |
| 854 | volume_before_rebuild = self.volumes_client.show_volume(volume_id) |
| 855 | image_before_rebuild = ( |
| 856 | volume_before_rebuild['volume'] |
| 857 | ['volume_image_metadata']['image_id']) |
| 858 | # Verify that image inside volume is our initial image before rebuild |
| 859 | self.assertEqual(self.image_ref, image_before_rebuild) |
| 860 | |
| 861 | # Authentication is attempted in the following order of priority: |
| 862 | # 1.The key passed in, if one was passed in. |
| 863 | # 2.Any key we can find through an SSH agent (if allowed). |
| 864 | # 3.Any "id_rsa", "id_dsa" or "id_ecdsa" key discoverable in |
| 865 | # ~/.ssh/ (if allowed). |
| 866 | # 4.Plain username/password auth, if a password was given. |
| 867 | linux_client = remote_client.RemoteClient( |
| 868 | self.get_server_ip(server, validation_resources), |
| 869 | self.ssh_user, |
| 870 | password=None, |
| 871 | pkey=validation_resources['keypair']['private_key'], |
| 872 | server=server, |
| 873 | servers_client=self.servers_client) |
| 874 | output = linux_client.exec_command('touch test_file') |
| 875 | # No output means success |
| 876 | self.assertEqual('', output.strip()) |
| 877 | |
| 878 | # The server should be rebuilt using the provided image and data |
| 879 | meta = {'rebuild': 'server'} |
| 880 | new_name = data_utils.rand_name(self.__class__.__name__ + '-server') |
| 881 | password = 'rebuildPassw0rd' |
| 882 | rebuilt_server = self.servers_client.rebuild_server( |
| 883 | server['id'], |
| 884 | self.image_ref_alt, |
| 885 | name=new_name, |
| 886 | metadata=meta, |
| 887 | adminPass=password)['server'] |
| 888 | |
| 889 | # Verify the properties in the initial response are correct |
| 890 | self.assertEqual(server['id'], rebuilt_server['id']) |
| 891 | rebuilt_image_id = rebuilt_server['image'] |
| 892 | # Since it is a volume backed server, image id will remain empty |
| 893 | self.assertEqual('', rebuilt_image_id) |
| 894 | self.assert_flavor_equal(self.flavor_ref, rebuilt_server['flavor']) |
| 895 | |
| 896 | # Verify the server properties after the rebuild completes |
| 897 | waiters.wait_for_server_status(self.servers_client, |
| 898 | rebuilt_server['id'], 'ACTIVE') |
| 899 | server = self.servers_client.show_server( |
| 900 | rebuilt_server['id'])['server'] |
| 901 | volume_id = server['os-extended-volumes:volumes_attached'][0]['id'] |
| 902 | volume_after_rebuild = self.volumes_client.show_volume(volume_id) |
| 903 | image_after_rebuild = ( |
| 904 | volume_after_rebuild['volume'] |
| 905 | ['volume_image_metadata']['image_id']) |
| 906 | |
| 907 | self.assertEqual(new_name, server['name']) |
| 908 | # Verify that volume ID remains same before and after rebuild |
| 909 | self.assertEqual(volume_before_rebuild['volume']['id'], |
| 910 | volume_after_rebuild['volume']['id']) |
| 911 | # Verify that image inside volume is our final image after rebuild |
| 912 | self.assertEqual(self.image_ref_alt, image_after_rebuild) |
| 913 | |
| 914 | # Authentication is attempted in the following order of priority: |
| 915 | # 1.The key passed in, if one was passed in. |
| 916 | # 2.Any key we can find through an SSH agent (if allowed). |
| 917 | # 3.Any "id_rsa", "id_dsa" or "id_ecdsa" key discoverable in |
| 918 | # ~/.ssh/ (if allowed). |
| 919 | # 4.Plain username/password auth, if a password was given. |
| 920 | linux_client = remote_client.RemoteClient( |
| 921 | self.get_server_ip(rebuilt_server, validation_resources), |
| 922 | self.ssh_alt_user, |
| 923 | password, |
| 924 | validation_resources['keypair']['private_key'], |
| 925 | server=rebuilt_server, |
| 926 | servers_client=self.servers_client) |
| 927 | linux_client.validate_authentication() |
| 928 | e = self.assertRaises(lib_exc.SSHExecCommandFailed, |
| 929 | linux_client.exec_command, |
| 930 | 'cat test_file') |
| 931 | # If we rebuilt the boot volume, then we should not find |
| 932 | # the file we touched. |
| 933 | self.assertIn('No such file or directory', str(e)) |