ZhiQiang Fan | 39f9722 | 2013-09-20 04:49:44 +0800 | [diff] [blame] | 1 | # Copyright 2012 OpenStack Foundation |
nithya-ganesan | e6a36c8 | 2013-02-15 14:38:27 +0000 | [diff] [blame] | 2 | # Copyright 2013 Hewlett-Packard Development Company, L.P. |
dwalleck | e62b9f0 | 2012-10-10 23:34:42 -0500 | [diff] [blame] | 3 | # All Rights Reserved. |
| 4 | # |
| 5 | # Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 6 | # not use this file except in compliance with the License. You may obtain |
| 7 | # a copy of the License at |
| 8 | # |
| 9 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | # |
| 11 | # Unless required by applicable law or agreed to in writing, software |
| 12 | # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 13 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 14 | # License for the specific language governing permissions and limitations |
| 15 | # under the License. |
| 16 | |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 17 | import json |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 18 | import time |
Matthew Treinish | 26dd0fa | 2012-12-04 17:14:37 -0500 | [diff] [blame] | 19 | import urllib |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 20 | |
Marc Koderer | 6fbd74f | 2014-08-04 09:38:19 +0200 | [diff] [blame] | 21 | from tempest.api_schema.response.compute import servers as common_schema |
| 22 | from tempest.api_schema.response.compute.v2 import servers as schema |
Haiwei Xu | ab92462 | 2014-03-05 04:33:51 +0900 | [diff] [blame] | 23 | from tempest.common import rest_client |
Attila Fazekas | 0abbc95 | 2013-07-01 19:19:42 +0200 | [diff] [blame] | 24 | from tempest.common import waiters |
Matthew Treinish | 684d899 | 2014-01-30 16:27:40 +0000 | [diff] [blame] | 25 | from tempest import config |
Matthew Treinish | a83a16e | 2012-12-07 13:44:02 -0500 | [diff] [blame] | 26 | from tempest import exceptions |
| 27 | |
Matthew Treinish | 684d899 | 2014-01-30 16:27:40 +0000 | [diff] [blame] | 28 | CONF = config.CONF |
| 29 | |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 30 | |
Haiwei Xu | ab92462 | 2014-03-05 04:33:51 +0900 | [diff] [blame] | 31 | class ServersClientJSON(rest_client.RestClient): |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 32 | |
Andrea Frittoli | 8bbdb16 | 2014-01-06 11:06:13 +0000 | [diff] [blame] | 33 | def __init__(self, auth_provider): |
| 34 | super(ServersClientJSON, self).__init__(auth_provider) |
| 35 | |
Matthew Treinish | 684d899 | 2014-01-30 16:27:40 +0000 | [diff] [blame] | 36 | self.service = CONF.compute.catalog_type |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 37 | |
Rohit Karajgi | 95446a2 | 2011-12-12 06:21:43 -0800 | [diff] [blame] | 38 | def create_server(self, name, image_ref, flavor_ref, **kwargs): |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 39 | """ |
| 40 | Creates an instance of a server. |
Rohit Karajgi | 95446a2 | 2011-12-12 06:21:43 -0800 | [diff] [blame] | 41 | name (Required): The name of the server. |
| 42 | image_ref (Required): Reference to the image used to build the server. |
| 43 | flavor_ref (Required): The flavor used to build the server. |
| 44 | Following optional keyword arguments are accepted: |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 45 | adminPass: Sets the initial root password. |
chris fattarsi | a6c2a73 | 2012-05-02 17:00:19 -0700 | [diff] [blame] | 46 | key_name: Key name of keypair that was created earlier. |
David Kranz | 28e79de | 2012-04-12 15:49:41 -0400 | [diff] [blame] | 47 | meta: A dictionary of values to be used as metadata. |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 48 | personality: A list of dictionaries for files to be injected into |
| 49 | the server. |
Rohit Karajgi | 95446a2 | 2011-12-12 06:21:43 -0800 | [diff] [blame] | 50 | security_groups: A list of security group dicts. |
| 51 | networks: A list of network dicts with UUID and fixed_ip. |
| 52 | user_data: User data for instance. |
| 53 | availability_zone: Availability zone in which to launch instance. |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 54 | accessIPv4: The IPv4 access address for the server. |
| 55 | accessIPv6: The IPv6 access address for the server. |
Rohit Karajgi | 95446a2 | 2011-12-12 06:21:43 -0800 | [diff] [blame] | 56 | min_count: Count of minimum number of instances to launch. |
| 57 | max_count: Count of maximum number of instances to launch. |
Daryl Walleck | e36d500 | 2012-03-28 09:56:10 -0500 | [diff] [blame] | 58 | disk_config: Determines if user or admin controls disk configuration. |
Mauro S. M. Rodrigues | c5da4f4 | 2013-03-04 23:57:10 -0500 | [diff] [blame] | 59 | return_reservation_id: Enable/Disable the return of reservation id |
Andrey Pavlov | 2a2fc41 | 2014-06-09 11:02:53 +0400 | [diff] [blame] | 60 | block_device_mapping: Block device mapping for the server. |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 61 | """ |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 62 | post_body = { |
| 63 | 'name': name, |
| 64 | 'imageRef': image_ref, |
David Kranz | 28e79de | 2012-04-12 15:49:41 -0400 | [diff] [blame] | 65 | 'flavorRef': flavor_ref |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 66 | } |
| 67 | |
chris fattarsi | a6c2a73 | 2012-05-02 17:00:19 -0700 | [diff] [blame] | 68 | for option in ['personality', 'adminPass', 'key_name', |
Zhongyue Luo | e0884a3 | 2012-09-25 17:24:17 +0800 | [diff] [blame] | 69 | 'security_groups', 'networks', 'user_data', |
| 70 | 'availability_zone', 'accessIPv4', 'accessIPv6', |
| 71 | 'min_count', 'max_count', ('metadata', 'meta'), |
Mauro S. M. Rodrigues | c5da4f4 | 2013-03-04 23:57:10 -0500 | [diff] [blame] | 72 | ('OS-DCF:diskConfig', 'disk_config'), |
Andrey Pavlov | 2a2fc41 | 2014-06-09 11:02:53 +0400 | [diff] [blame] | 73 | 'return_reservation_id', 'block_device_mapping']: |
David Kranz | 28e79de | 2012-04-12 15:49:41 -0400 | [diff] [blame] | 74 | if isinstance(option, tuple): |
| 75 | post_param = option[0] |
| 76 | key = option[1] |
| 77 | else: |
| 78 | post_param = option |
| 79 | key = option |
| 80 | value = kwargs.get(key) |
Zhongyue Luo | e471d6e | 2012-09-17 17:02:43 +0800 | [diff] [blame] | 81 | if value is not None: |
David Kranz | 28e79de | 2012-04-12 15:49:41 -0400 | [diff] [blame] | 82 | post_body[post_param] = value |
raiesmh08 | cbe21b0 | 2014-03-12 17:04:44 +0530 | [diff] [blame] | 83 | post_body = {'server': post_body} |
| 84 | |
| 85 | if 'sched_hints' in kwargs: |
| 86 | hints = {'os:scheduler_hints': kwargs.get('sched_hints')} |
| 87 | post_body = dict(post_body.items() + hints.items()) |
| 88 | post_body = json.dumps(post_body) |
vponomaryov | f4c27f9 | 2014-02-18 10:56:42 +0200 | [diff] [blame] | 89 | resp, body = self.post('servers', post_body) |
Jay Pipes | 5135bfc | 2012-01-05 15:46:49 -0500 | [diff] [blame] | 90 | |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 91 | body = json.loads(body) |
Mauro S. M. Rodrigues | c5da4f4 | 2013-03-04 23:57:10 -0500 | [diff] [blame] | 92 | # NOTE(maurosr): this deals with the case of multiple server create |
| 93 | # with return reservation id set True |
| 94 | if 'reservation_id' in body: |
| 95 | return resp, body |
Ghanshyam | 7f98910 | 2014-07-29 14:23:26 +0900 | [diff] [blame] | 96 | if CONF.compute_feature_enabled.enable_instance_password: |
| 97 | create_schema = schema.create_server_with_admin_pass |
| 98 | else: |
| 99 | create_schema = schema.create_server |
| 100 | self.validate_response(create_schema, resp, body) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 101 | return resp, body['server'] |
| 102 | |
| 103 | def update_server(self, server_id, name=None, meta=None, accessIPv4=None, |
ivan-zhu | 72d7d5b | 2013-10-16 17:30:58 +0800 | [diff] [blame] | 104 | accessIPv6=None, disk_config=None): |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 105 | """ |
| 106 | Updates the properties of an existing server. |
| 107 | server_id: The id of an existing server. |
| 108 | name: The name of the server. |
| 109 | personality: A list of files to be injected into the server. |
| 110 | accessIPv4: The IPv4 access address for the server. |
| 111 | accessIPv6: The IPv6 access address for the server. |
| 112 | """ |
| 113 | |
| 114 | post_body = {} |
| 115 | |
Zhongyue Luo | e471d6e | 2012-09-17 17:02:43 +0800 | [diff] [blame] | 116 | if meta is not None: |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 117 | post_body['metadata'] = meta |
| 118 | |
Zhongyue Luo | e471d6e | 2012-09-17 17:02:43 +0800 | [diff] [blame] | 119 | if name is not None: |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 120 | post_body['name'] = name |
| 121 | |
Zhongyue Luo | e471d6e | 2012-09-17 17:02:43 +0800 | [diff] [blame] | 122 | if accessIPv4 is not None: |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 123 | post_body['accessIPv4'] = accessIPv4 |
| 124 | |
Zhongyue Luo | e471d6e | 2012-09-17 17:02:43 +0800 | [diff] [blame] | 125 | if accessIPv6 is not None: |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 126 | post_body['accessIPv6'] = accessIPv6 |
| 127 | |
ivan-zhu | 72d7d5b | 2013-10-16 17:30:58 +0800 | [diff] [blame] | 128 | if disk_config is not None: |
| 129 | post_body['OS-DCF:diskConfig'] = disk_config |
| 130 | |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 131 | post_body = json.dumps({'server': post_body}) |
vponomaryov | f4c27f9 | 2014-02-18 10:56:42 +0200 | [diff] [blame] | 132 | resp, body = self.put("servers/%s" % str(server_id), post_body) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 133 | body = json.loads(body) |
Ken'ichi Ohmichi | 29cd512 | 2014-04-28 11:04:52 +0900 | [diff] [blame] | 134 | self.validate_response(schema.update_server, resp, body) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 135 | return resp, body['server'] |
| 136 | |
| 137 | def get_server(self, server_id): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 138 | """Returns the details of an existing server.""" |
chris fattarsi | 5098fa2 | 2012-04-17 13:27:00 -0700 | [diff] [blame] | 139 | resp, body = self.get("servers/%s" % str(server_id)) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 140 | body = json.loads(body) |
Ken'ichi Ohmichi | 21e4fc7 | 2014-05-08 16:46:23 +0900 | [diff] [blame] | 141 | self.validate_response(schema.get_server, resp, body) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 142 | return resp, body['server'] |
| 143 | |
| 144 | def delete_server(self, server_id): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 145 | """Deletes the given server.""" |
Ghanshyam | 4ac0274 | 2014-04-17 19:15:47 +0900 | [diff] [blame] | 146 | resp, body = self.delete("servers/%s" % str(server_id)) |
| 147 | self.validate_response(common_schema.delete_server, resp, body) |
| 148 | return resp, body |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 149 | |
| 150 | def list_servers(self, params=None): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 151 | """Lists all servers for a user.""" |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 152 | |
| 153 | url = 'servers' |
Matthew Treinish | 26dd0fa | 2012-12-04 17:14:37 -0500 | [diff] [blame] | 154 | if params: |
| 155 | url += '?%s' % urllib.urlencode(params) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 156 | |
chris fattarsi | 5098fa2 | 2012-04-17 13:27:00 -0700 | [diff] [blame] | 157 | resp, body = self.get(url) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 158 | body = json.loads(body) |
Ghanshyam | 623c38f | 2014-04-21 17:16:21 +0900 | [diff] [blame] | 159 | self.validate_response(common_schema.list_servers, resp, body) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 160 | return resp, body |
| 161 | |
| 162 | def list_servers_with_detail(self, params=None): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 163 | """Lists all servers in detail for a user.""" |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 164 | |
| 165 | url = 'servers/detail' |
Matthew Treinish | 26dd0fa | 2012-12-04 17:14:37 -0500 | [diff] [blame] | 166 | if params: |
| 167 | url += '?%s' % urllib.urlencode(params) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 168 | |
chris fattarsi | 5098fa2 | 2012-04-17 13:27:00 -0700 | [diff] [blame] | 169 | resp, body = self.get(url) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 170 | body = json.loads(body) |
Ghanshyam | 5174486 | 2014-06-13 12:56:24 +0900 | [diff] [blame] | 171 | self.validate_response(schema.list_servers_detail, resp, body) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 172 | return resp, body |
| 173 | |
Zhi Kun Liu | e540176 | 2013-09-11 20:45:48 +0800 | [diff] [blame] | 174 | def wait_for_server_status(self, server_id, status, extra_timeout=0, |
| 175 | raise_on_error=True): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 176 | """Waits for a server to reach a given status.""" |
Ken'ichi Ohmichi | 39437e2 | 2013-10-06 00:21:38 +0900 | [diff] [blame] | 177 | return waiters.wait_for_server_status(self, server_id, status, |
Zhi Kun Liu | e540176 | 2013-09-11 20:45:48 +0800 | [diff] [blame] | 178 | extra_timeout=extra_timeout, |
| 179 | raise_on_error=raise_on_error) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 180 | |
Jay Pipes | 051075a | 2012-04-28 17:39:37 -0400 | [diff] [blame] | 181 | def wait_for_server_termination(self, server_id, ignore_error=False): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 182 | """Waits for server to reach termination.""" |
Rohit Karajgi | 4a64d23 | 2012-05-17 07:44:37 -0700 | [diff] [blame] | 183 | start_time = int(time.time()) |
| 184 | while True: |
| 185 | try: |
| 186 | resp, body = self.get_server(server_id) |
| 187 | except exceptions.NotFound: |
| 188 | return |
| 189 | |
| 190 | server_status = body['status'] |
Jay Pipes | 051075a | 2012-04-28 17:39:37 -0400 | [diff] [blame] | 191 | if server_status == 'ERROR' and not ignore_error: |
Jay Pipes | 444c3e6 | 2012-10-04 19:26:35 -0400 | [diff] [blame] | 192 | raise exceptions.BuildErrorException(server_id=server_id) |
Rohit Karajgi | 4a64d23 | 2012-05-17 07:44:37 -0700 | [diff] [blame] | 193 | |
| 194 | if int(time.time()) - start_time >= self.build_timeout: |
| 195 | raise exceptions.TimeoutException |
| 196 | |
| 197 | time.sleep(self.build_interval) |
| 198 | |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 199 | def list_addresses(self, server_id): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 200 | """Lists all addresses for a server.""" |
chris fattarsi | 5098fa2 | 2012-04-17 13:27:00 -0700 | [diff] [blame] | 201 | resp, body = self.get("servers/%s/ips" % str(server_id)) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 202 | body = json.loads(body) |
Ghanshyam | d847c58 | 2014-05-07 16:21:36 +0900 | [diff] [blame] | 203 | self.validate_response(schema.list_addresses, resp, body) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 204 | return resp, body['addresses'] |
| 205 | |
| 206 | def list_addresses_by_network(self, server_id, network_id): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 207 | """Lists all addresses of a specific network type for a server.""" |
chris fattarsi | 5098fa2 | 2012-04-17 13:27:00 -0700 | [diff] [blame] | 208 | resp, body = self.get("servers/%s/ips/%s" % |
Zhongyue Luo | e0884a3 | 2012-09-25 17:24:17 +0800 | [diff] [blame] | 209 | (str(server_id), network_id)) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 210 | body = json.loads(body) |
Ghanshyam | 9541ad1 | 2014-05-07 16:38:43 +0900 | [diff] [blame] | 211 | self.validate_response(schema.list_addresses_by_network, resp, body) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 212 | return resp, body |
| 213 | |
Ghanshyam | d6d3040 | 2014-04-02 15:28:37 +0900 | [diff] [blame] | 214 | def action(self, server_id, action_name, response_key, |
Ghanshyam | 997c909 | 2014-04-03 19:00:20 +0900 | [diff] [blame] | 215 | schema=common_schema.server_actions_common_schema, **kwargs): |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 216 | post_body = json.dumps({action_name: kwargs}) |
| 217 | resp, body = self.post('servers/%s/action' % str(server_id), |
vponomaryov | f4c27f9 | 2014-02-18 10:56:42 +0200 | [diff] [blame] | 218 | post_body) |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 219 | if response_key is not None: |
Ghanshyam | d6d3040 | 2014-04-02 15:28:37 +0900 | [diff] [blame] | 220 | body = json.loads(body) |
Ghanshyam | 7ee264a | 2014-04-02 16:37:57 +0900 | [diff] [blame] | 221 | # Check for Schema as 'None' because if we do not have any server |
Ghanshyam | d6d3040 | 2014-04-02 15:28:37 +0900 | [diff] [blame] | 222 | # action schema implemented yet then they can pass 'None' to skip |
| 223 | # the validation.Once all server action has their schema |
| 224 | # implemented then, this check can be removed if every actions are |
| 225 | # supposed to validate their response. |
Ghanshyam | 7ee264a | 2014-04-02 16:37:57 +0900 | [diff] [blame] | 226 | # TODO(GMann): Remove the below 'if' check once all server actions |
| 227 | # schema are implemented. |
Ghanshyam | d6d3040 | 2014-04-02 15:28:37 +0900 | [diff] [blame] | 228 | if schema is not None: |
| 229 | self.validate_response(schema, resp, body) |
| 230 | body = body[response_key] |
Ghanshyam | 997c909 | 2014-04-03 19:00:20 +0900 | [diff] [blame] | 231 | else: |
| 232 | self.validate_response(schema, resp, body) |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 233 | return resp, body |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 234 | |
ivan-zhu | ccc8946 | 2013-10-31 16:53:12 +0800 | [diff] [blame] | 235 | def create_backup(self, server_id, backup_type, rotation, name): |
| 236 | """Backup a server instance.""" |
| 237 | return self.action(server_id, "createBackup", None, |
| 238 | backup_type=backup_type, |
| 239 | rotation=rotation, |
| 240 | name=name) |
| 241 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 242 | def change_password(self, server_id, adminPass): |
| 243 | """Changes the root password for the server.""" |
| 244 | return self.action(server_id, 'changePassword', None, |
| 245 | adminPass=adminPass) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 246 | |
ivan-zhu | 6de5b04 | 2013-10-24 17:21:48 +0800 | [diff] [blame] | 247 | def get_password(self, server_id): |
| 248 | resp, body = self.get("servers/%s/os-server-password" % |
| 249 | str(server_id)) |
| 250 | body = json.loads(body) |
Ghanshyam | 7fa397c | 2014-04-01 19:32:38 +0900 | [diff] [blame] | 251 | self.validate_response(common_schema.get_password, resp, body) |
ivan-zhu | 6de5b04 | 2013-10-24 17:21:48 +0800 | [diff] [blame] | 252 | return resp, body |
| 253 | |
| 254 | def delete_password(self, server_id): |
| 255 | """ |
| 256 | Removes the encrypted server password from the metadata server |
| 257 | Note that this does not actually change the instance server |
| 258 | password. |
| 259 | """ |
Ghanshyam | 997c909 | 2014-04-03 19:00:20 +0900 | [diff] [blame] | 260 | resp, body = self.delete("servers/%s/os-server-password" % |
| 261 | str(server_id)) |
| 262 | self.validate_response(common_schema.server_actions_delete_password, |
| 263 | resp, body) |
| 264 | return resp, body |
ivan-zhu | 6de5b04 | 2013-10-24 17:21:48 +0800 | [diff] [blame] | 265 | |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 266 | def reboot(self, server_id, reboot_type): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 267 | """Reboots a server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 268 | return self.action(server_id, 'reboot', None, type=reboot_type) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 269 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 270 | def rebuild(self, server_id, image_ref, **kwargs): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 271 | """Rebuilds a server with a new image.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 272 | kwargs['imageRef'] = image_ref |
| 273 | if 'disk_config' in kwargs: |
| 274 | kwargs['OS-DCF:diskConfig'] = kwargs['disk_config'] |
| 275 | del kwargs['disk_config'] |
Ghanshyam | 9c2e50d | 2014-07-22 21:32:05 +0900 | [diff] [blame] | 276 | if CONF.compute_feature_enabled.enable_instance_password: |
| 277 | rebuild_schema = schema.rebuild_server_with_admin_pass |
| 278 | else: |
| 279 | rebuild_schema = schema.rebuild_server |
| 280 | return self.action(server_id, 'rebuild', 'server', |
| 281 | rebuild_schema, **kwargs) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 282 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 283 | def resize(self, server_id, flavor_ref, **kwargs): |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 284 | """Changes the flavor of a server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 285 | kwargs['flavorRef'] = flavor_ref |
| 286 | if 'disk_config' in kwargs: |
| 287 | kwargs['OS-DCF:diskConfig'] = kwargs['disk_config'] |
| 288 | del kwargs['disk_config'] |
| 289 | return self.action(server_id, 'resize', None, **kwargs) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 290 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 291 | def confirm_resize(self, server_id, **kwargs): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 292 | """Confirms the flavor change for a server.""" |
Ghanshyam | 997c909 | 2014-04-03 19:00:20 +0900 | [diff] [blame] | 293 | return self.action(server_id, 'confirmResize', |
| 294 | None, schema.server_actions_confirm_resize, |
| 295 | **kwargs) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 296 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 297 | def revert_resize(self, server_id, **kwargs): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 298 | """Reverts a server back to its original flavor.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 299 | return self.action(server_id, 'revertResize', None, **kwargs) |
Daryl Walleck | e5b83d4 | 2011-11-10 14:39:02 -0600 | [diff] [blame] | 300 | |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 301 | def list_server_metadata(self, server_id): |
chris fattarsi | 5098fa2 | 2012-04-17 13:27:00 -0700 | [diff] [blame] | 302 | resp, body = self.get("servers/%s/metadata" % str(server_id)) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 303 | body = json.loads(body) |
Ghanshyam | a8f6653 | 2014-04-23 17:18:14 +0900 | [diff] [blame] | 304 | self.validate_response(common_schema.list_server_metadata, resp, body) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 305 | return resp, body['metadata'] |
| 306 | |
Chris Yeoh | d0b52e7 | 2013-09-17 22:38:59 +0930 | [diff] [blame] | 307 | def set_server_metadata(self, server_id, meta, no_metadata_field=False): |
| 308 | if no_metadata_field: |
| 309 | post_body = "" |
| 310 | else: |
| 311 | post_body = json.dumps({'metadata': meta}) |
Zhongyue Luo | e0884a3 | 2012-09-25 17:24:17 +0800 | [diff] [blame] | 312 | resp, body = self.put('servers/%s/metadata' % str(server_id), |
vponomaryov | f4c27f9 | 2014-02-18 10:56:42 +0200 | [diff] [blame] | 313 | post_body) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 314 | body = json.loads(body) |
Haiwei Xu | 3d2b7af | 2014-04-12 02:50:26 +0900 | [diff] [blame] | 315 | self.validate_response(common_schema.set_server_metadata, resp, body) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 316 | return resp, body['metadata'] |
| 317 | |
| 318 | def update_server_metadata(self, server_id, meta): |
| 319 | post_body = json.dumps({'metadata': meta}) |
Zhongyue Luo | e0884a3 | 2012-09-25 17:24:17 +0800 | [diff] [blame] | 320 | resp, body = self.post('servers/%s/metadata' % str(server_id), |
vponomaryov | f4c27f9 | 2014-02-18 10:56:42 +0200 | [diff] [blame] | 321 | post_body) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 322 | body = json.loads(body) |
Ghanshyam | e842106 | 2014-06-02 15:58:21 +0900 | [diff] [blame] | 323 | self.validate_response(common_schema.update_server_metadata, |
| 324 | resp, body) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 325 | return resp, body['metadata'] |
| 326 | |
| 327 | def get_server_metadata_item(self, server_id, key): |
Zhongyue Luo | e0884a3 | 2012-09-25 17:24:17 +0800 | [diff] [blame] | 328 | resp, body = self.get("servers/%s/metadata/%s" % (str(server_id), key)) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 329 | body = json.loads(body) |
Ghanshyam | eaaa6a4 | 2014-04-25 18:38:21 +0900 | [diff] [blame] | 330 | self.validate_response(schema.set_get_server_metadata_item, |
| 331 | resp, body) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 332 | return resp, body['meta'] |
| 333 | |
| 334 | def set_server_metadata_item(self, server_id, key, meta): |
| 335 | post_body = json.dumps({'meta': meta}) |
Zhongyue Luo | e0884a3 | 2012-09-25 17:24:17 +0800 | [diff] [blame] | 336 | resp, body = self.put('servers/%s/metadata/%s' % (str(server_id), key), |
vponomaryov | f4c27f9 | 2014-02-18 10:56:42 +0200 | [diff] [blame] | 337 | post_body) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 338 | body = json.loads(body) |
Ghanshyam | eaaa6a4 | 2014-04-25 18:38:21 +0900 | [diff] [blame] | 339 | self.validate_response(schema.set_get_server_metadata_item, |
| 340 | resp, body) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 341 | return resp, body['meta'] |
| 342 | |
| 343 | def delete_server_metadata_item(self, server_id, key): |
chris fattarsi | 5098fa2 | 2012-04-17 13:27:00 -0700 | [diff] [blame] | 344 | resp, body = self.delete("servers/%s/metadata/%s" % |
Zhongyue Luo | e0884a3 | 2012-09-25 17:24:17 +0800 | [diff] [blame] | 345 | (str(server_id), key)) |
Ghanshyam | eaaa6a4 | 2014-04-25 18:38:21 +0900 | [diff] [blame] | 346 | self.validate_response(common_schema.delete_server_metadata_item, |
| 347 | resp, body) |
Daryl Walleck | 73a9e7a | 2011-11-15 17:43:31 -0600 | [diff] [blame] | 348 | return resp, body |
Dan Smith | c18d8c6 | 2012-07-02 08:09:26 -0700 | [diff] [blame] | 349 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 350 | def stop(self, server_id, **kwargs): |
| 351 | return self.action(server_id, 'os-stop', None, **kwargs) |
Dan Smith | c18d8c6 | 2012-07-02 08:09:26 -0700 | [diff] [blame] | 352 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 353 | def start(self, server_id, **kwargs): |
| 354 | return self.action(server_id, 'os-start', None, **kwargs) |
Dan Smith | c18d8c6 | 2012-07-02 08:09:26 -0700 | [diff] [blame] | 355 | |
| 356 | def attach_volume(self, server_id, volume_id, device='/dev/vdz'): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 357 | """Attaches a volume to a server instance.""" |
Zhongyue Luo | 30a563f | 2012-09-30 23:43:50 +0900 | [diff] [blame] | 358 | post_body = json.dumps({ |
| 359 | 'volumeAttachment': { |
| 360 | 'volumeId': volume_id, |
| 361 | 'device': device, |
| 362 | } |
| 363 | }) |
Dan Smith | c18d8c6 | 2012-07-02 08:09:26 -0700 | [diff] [blame] | 364 | resp, body = self.post('servers/%s/os-volume_attachments' % server_id, |
vponomaryov | f4c27f9 | 2014-02-18 10:56:42 +0200 | [diff] [blame] | 365 | post_body) |
Ghanshyam | 385c4e7 | 2014-03-27 11:42:25 +0900 | [diff] [blame] | 366 | body = json.loads(body) |
| 367 | self.validate_response(schema.attach_volume, resp, body) |
Dan Smith | c18d8c6 | 2012-07-02 08:09:26 -0700 | [diff] [blame] | 368 | return resp, body |
| 369 | |
| 370 | def detach_volume(self, server_id, volume_id): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 371 | """Detaches a volume from a server instance.""" |
Dan Smith | c18d8c6 | 2012-07-02 08:09:26 -0700 | [diff] [blame] | 372 | resp, body = self.delete('servers/%s/os-volume_attachments/%s' % |
| 373 | (server_id, volume_id)) |
Ghanshyam | 385c4e7 | 2014-03-27 11:42:25 +0900 | [diff] [blame] | 374 | self.validate_response(schema.detach_volume, resp, body) |
Dan Smith | c18d8c6 | 2012-07-02 08:09:26 -0700 | [diff] [blame] | 375 | return resp, body |
sapan-kona | 775cf63 | 2012-06-22 00:32:36 +0530 | [diff] [blame] | 376 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 377 | def add_security_group(self, server_id, name): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 378 | """Adds a security group to the server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 379 | return self.action(server_id, 'addSecurityGroup', None, name=name) |
sapan-kona | 775cf63 | 2012-06-22 00:32:36 +0530 | [diff] [blame] | 380 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 381 | def remove_security_group(self, server_id, name): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 382 | """Removes a security group from the server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 383 | return self.action(server_id, 'removeSecurityGroup', None, name=name) |
Mate Lakat | 99ee914 | 2012-09-14 12:34:46 +0100 | [diff] [blame] | 384 | |
| 385 | def live_migrate_server(self, server_id, dest_host, use_block_migration): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 386 | """This should be called with administrator privileges .""" |
Mate Lakat | 99ee914 | 2012-09-14 12:34:46 +0100 | [diff] [blame] | 387 | |
| 388 | migrate_params = { |
| 389 | "disk_over_commit": False, |
| 390 | "block_migration": use_block_migration, |
| 391 | "host": dest_host |
| 392 | } |
| 393 | |
| 394 | req_body = json.dumps({'os-migrateLive': migrate_params}) |
| 395 | |
vponomaryov | f4c27f9 | 2014-02-18 10:56:42 +0200 | [diff] [blame] | 396 | resp, body = self.post("servers/%s/action" % str(server_id), req_body) |
Ghanshyam | 997c909 | 2014-04-03 19:00:20 +0900 | [diff] [blame] | 397 | self.validate_response(common_schema.server_actions_common_schema, |
| 398 | resp, body) |
Mate Lakat | 99ee914 | 2012-09-14 12:34:46 +0100 | [diff] [blame] | 399 | return resp, body |
Daryl Walleck | 3d3f610 | 2012-11-09 15:16:42 -0600 | [diff] [blame] | 400 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 401 | def migrate_server(self, server_id, **kwargs): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 402 | """Migrates a server to a new host.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 403 | return self.action(server_id, 'migrate', None, **kwargs) |
Daryl Walleck | 3d3f610 | 2012-11-09 15:16:42 -0600 | [diff] [blame] | 404 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 405 | def lock_server(self, server_id, **kwargs): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 406 | """Locks the given server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 407 | return self.action(server_id, 'lock', None, **kwargs) |
Daryl Walleck | 3d3f610 | 2012-11-09 15:16:42 -0600 | [diff] [blame] | 408 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 409 | def unlock_server(self, server_id, **kwargs): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 410 | """UNlocks the given server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 411 | return self.action(server_id, 'unlock', None, **kwargs) |
Daryl Walleck | 3d3f610 | 2012-11-09 15:16:42 -0600 | [diff] [blame] | 412 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 413 | def suspend_server(self, server_id, **kwargs): |
Ken'ichi Ohmichi | 39437e2 | 2013-10-06 00:21:38 +0900 | [diff] [blame] | 414 | """Suspends the provided server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 415 | return self.action(server_id, 'suspend', None, **kwargs) |
Daryl Walleck | 3d3f610 | 2012-11-09 15:16:42 -0600 | [diff] [blame] | 416 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 417 | def resume_server(self, server_id, **kwargs): |
Ken'ichi Ohmichi | 39437e2 | 2013-10-06 00:21:38 +0900 | [diff] [blame] | 418 | """Un-suspends the provided server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 419 | return self.action(server_id, 'resume', None, **kwargs) |
Daryl Walleck | 3d3f610 | 2012-11-09 15:16:42 -0600 | [diff] [blame] | 420 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 421 | def pause_server(self, server_id, **kwargs): |
Ken'ichi Ohmichi | 39437e2 | 2013-10-06 00:21:38 +0900 | [diff] [blame] | 422 | """Pauses the provided server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 423 | return self.action(server_id, 'pause', None, **kwargs) |
Daryl Walleck | 3d3f610 | 2012-11-09 15:16:42 -0600 | [diff] [blame] | 424 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 425 | def unpause_server(self, server_id, **kwargs): |
Ken'ichi Ohmichi | 39437e2 | 2013-10-06 00:21:38 +0900 | [diff] [blame] | 426 | """Un-pauses the provided server.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 427 | return self.action(server_id, 'unpause', None, **kwargs) |
Daryl Walleck | 3d3f610 | 2012-11-09 15:16:42 -0600 | [diff] [blame] | 428 | |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 429 | def reset_state(self, server_id, state='error'): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 430 | """Resets the state of a server to active/error.""" |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 431 | return self.action(server_id, 'os-resetState', None, state=state) |
Attila Fazekas | e4cb04c | 2013-01-29 09:51:58 +0100 | [diff] [blame] | 432 | |
Ken'ichi Ohmichi | 39437e2 | 2013-10-06 00:21:38 +0900 | [diff] [blame] | 433 | def shelve_server(self, server_id, **kwargs): |
| 434 | """Shelves the provided server.""" |
| 435 | return self.action(server_id, 'shelve', None, **kwargs) |
| 436 | |
| 437 | def unshelve_server(self, server_id, **kwargs): |
| 438 | """Un-shelves the provided server.""" |
| 439 | return self.action(server_id, 'unshelve', None, **kwargs) |
| 440 | |
Ken'ichi Ohmichi | 17b7f11 | 2014-02-20 06:33:49 +0900 | [diff] [blame] | 441 | def shelve_offload_server(self, server_id, **kwargs): |
| 442 | """Shelve-offload the provided server.""" |
| 443 | return self.action(server_id, 'shelveOffload', None, **kwargs) |
| 444 | |
Attila Fazekas | e4cb04c | 2013-01-29 09:51:58 +0100 | [diff] [blame] | 445 | def get_console_output(self, server_id, length): |
Davanum Srinivas | 8a841c7 | 2014-06-19 18:33:14 -0400 | [diff] [blame] | 446 | kwargs = {'length': length} if length else {} |
Attila Fazekas | d429928 | 2013-02-22 13:25:23 +0100 | [diff] [blame] | 447 | return self.action(server_id, 'os-getConsoleOutput', 'output', |
Davanum Srinivas | 8a841c7 | 2014-06-19 18:33:14 -0400 | [diff] [blame] | 448 | common_schema.get_console_output, **kwargs) |
Rami Vaknin | 76bc8bd | 2013-02-17 16:18:27 +0200 | [diff] [blame] | 449 | |
| 450 | def list_virtual_interfaces(self, server_id): |
| 451 | """ |
| 452 | List the virtual interfaces used in an instance. |
| 453 | """ |
| 454 | resp, body = self.get('/'.join(['servers', server_id, |
| 455 | 'os-virtual-interfaces'])) |
Ghanshyam | 08ce58d | 2014-04-04 14:51:14 +0900 | [diff] [blame] | 456 | body = json.loads(body) |
| 457 | self.validate_response(schema.list_virtual_interfaces, resp, body) |
| 458 | return resp, body |
nithya-ganesan | e6a36c8 | 2013-02-15 14:38:27 +0000 | [diff] [blame] | 459 | |
Yuiko Takada | 7835d50 | 2014-01-15 10:15:03 +0000 | [diff] [blame] | 460 | def rescue_server(self, server_id, **kwargs): |
nithya-ganesan | e6a36c8 | 2013-02-15 14:38:27 +0000 | [diff] [blame] | 461 | """Rescue the provided server.""" |
Ghanshyam | 8845791 | 2014-07-25 16:02:12 +0900 | [diff] [blame] | 462 | return self.action(server_id, 'rescue', 'adminPass', |
| 463 | schema.rescue_server, **kwargs) |
nithya-ganesan | e6a36c8 | 2013-02-15 14:38:27 +0000 | [diff] [blame] | 464 | |
| 465 | def unrescue_server(self, server_id): |
| 466 | """Unrescue the provided server.""" |
| 467 | return self.action(server_id, 'unrescue', None) |
Leo Toyoda | faca6ff | 2013-04-22 16:52:53 +0900 | [diff] [blame] | 468 | |
Zhu Zhu | da07085 | 2013-09-25 08:07:57 -0500 | [diff] [blame] | 469 | def get_server_diagnostics(self, server_id): |
| 470 | """Get the usage data for a server.""" |
| 471 | resp, body = self.get("servers/%s/diagnostics" % str(server_id)) |
| 472 | return resp, json.loads(body) |
| 473 | |
Leo Toyoda | faca6ff | 2013-04-22 16:52:53 +0900 | [diff] [blame] | 474 | def list_instance_actions(self, server_id): |
| 475 | """List the provided server action.""" |
| 476 | resp, body = self.get("servers/%s/os-instance-actions" % |
| 477 | str(server_id)) |
| 478 | body = json.loads(body) |
Ghanshyam | 2996609 | 2014-04-07 17:27:41 +0900 | [diff] [blame] | 479 | self.validate_response(schema.list_instance_actions, resp, body) |
Leo Toyoda | faca6ff | 2013-04-22 16:52:53 +0900 | [diff] [blame] | 480 | return resp, body['instanceActions'] |
| 481 | |
| 482 | def get_instance_action(self, server_id, request_id): |
| 483 | """Returns the action details of the provided server.""" |
| 484 | resp, body = self.get("servers/%s/os-instance-actions/%s" % |
| 485 | (str(server_id), str(request_id))) |
| 486 | body = json.loads(body) |
Ghanshyam | 4b41dfd | 2014-07-17 13:40:38 +0900 | [diff] [blame] | 487 | self.validate_response(schema.get_instance_action, resp, body) |
Leo Toyoda | faca6ff | 2013-04-22 16:52:53 +0900 | [diff] [blame] | 488 | return resp, body['instanceAction'] |
Lingxian Kong | aecc109 | 2013-10-03 16:18:46 +0800 | [diff] [blame] | 489 | |
| 490 | def force_delete_server(self, server_id, **kwargs): |
| 491 | """Force delete a server.""" |
| 492 | return self.action(server_id, 'forceDelete', None, **kwargs) |
| 493 | |
| 494 | def restore_soft_deleted_server(self, server_id, **kwargs): |
| 495 | """Restore a soft-deleted server.""" |
| 496 | return self.action(server_id, 'restore', None, **kwargs) |
Ghanshyam Mann | 79f4a09 | 2014-02-27 21:01:31 +0900 | [diff] [blame] | 497 | |
| 498 | def reset_network(self, server_id, **kwargs): |
| 499 | """Resets the Network of a server""" |
| 500 | return self.action(server_id, 'resetNetwork', None, **kwargs) |
| 501 | |
| 502 | def inject_network_info(self, server_id, **kwargs): |
| 503 | """Inject the Network Info into server""" |
| 504 | return self.action(server_id, 'injectNetworkInfo', None, **kwargs) |
Ghanshyam | 86d1a57 | 2014-03-05 10:19:25 +0900 | [diff] [blame] | 505 | |
| 506 | def get_vnc_console(self, server_id, console_type): |
| 507 | """Get URL of VNC console.""" |
| 508 | return self.action(server_id, "os-getVNCConsole", |
Ghanshyam | d6d3040 | 2014-04-02 15:28:37 +0900 | [diff] [blame] | 509 | "console", common_schema.get_vnc_console, |
| 510 | type=console_type) |
Abhijeet.Jain | 87dd445 | 2014-04-23 15:51:23 +0530 | [diff] [blame] | 511 | |
| 512 | def create_server_group(self, name, policies): |
| 513 | """ |
| 514 | Create the server group |
| 515 | name : Name of the server-group |
| 516 | policies : List of the policies - affinity/anti-affinity) |
| 517 | """ |
| 518 | post_body = { |
| 519 | 'name': name, |
| 520 | 'policies': policies, |
| 521 | } |
| 522 | |
| 523 | post_body = json.dumps({'server_group': post_body}) |
| 524 | resp, body = self.post('os-server-groups', post_body) |
| 525 | |
| 526 | body = json.loads(body) |
Ghanshyam | f81f9fa | 2014-05-23 13:38:56 +0900 | [diff] [blame] | 527 | self.validate_response(schema.create_get_server_group, resp, body) |
Abhijeet.Jain | 87dd445 | 2014-04-23 15:51:23 +0530 | [diff] [blame] | 528 | return resp, body['server_group'] |
| 529 | |
| 530 | def delete_server_group(self, server_group_id): |
| 531 | """Delete the given server-group.""" |
Ghanshyam | f81f9fa | 2014-05-23 13:38:56 +0900 | [diff] [blame] | 532 | resp, body = self.delete("os-server-groups/%s" % str(server_group_id)) |
| 533 | self.validate_response(schema.delete_server_group, resp, body) |
| 534 | return resp, body |
Abhijeet.Jain | 87dd445 | 2014-04-23 15:51:23 +0530 | [diff] [blame] | 535 | |
| 536 | def list_server_groups(self): |
| 537 | """List the server-groups.""" |
| 538 | resp, body = self.get("os-server-groups") |
| 539 | body = json.loads(body) |
Ghanshyam | 438ed3b | 2014-06-18 17:25:41 +0900 | [diff] [blame] | 540 | self.validate_response(schema.list_server_groups, resp, body) |
Abhijeet.Jain | 87dd445 | 2014-04-23 15:51:23 +0530 | [diff] [blame] | 541 | return resp, body['server_groups'] |
| 542 | |
| 543 | def get_server_group(self, server_group_id): |
| 544 | """Get the details of given server_group.""" |
| 545 | resp, body = self.get("os-server-groups/%s" % str(server_group_id)) |
| 546 | body = json.loads(body) |
Ghanshyam | f81f9fa | 2014-05-23 13:38:56 +0900 | [diff] [blame] | 547 | self.validate_response(schema.create_get_server_group, resp, body) |
Abhijeet.Jain | 87dd445 | 2014-04-23 15:51:23 +0530 | [diff] [blame] | 548 | return resp, body['server_group'] |