Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 1 | # Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 2 | # not use this file except in compliance with the License. You may obtain |
| 3 | # a copy of the License at |
| 4 | # |
| 5 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 6 | # |
| 7 | # Unless required by applicable law or agreed to in writing, software |
| 8 | # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 9 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 10 | # License for the specific language governing permissions and limitations |
| 11 | # under the License. |
| 12 | |
| 13 | import functools |
| 14 | |
| 15 | from oslo_serialization import jsonutils as json |
Solio Sarabia | f78122e | 2017-02-23 16:17:34 -0600 | [diff] [blame] | 16 | from six.moves import http_client |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 17 | from six.moves.urllib import parse as urllib |
Yuiko Takada | ff78500 | 2015-12-17 15:56:42 +0900 | [diff] [blame] | 18 | from tempest.lib.common import api_version_utils |
Lenny Verkhovsky | 8862504 | 2016-03-08 17:44:00 +0200 | [diff] [blame] | 19 | from tempest.lib.common import rest_client |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 20 | |
Vasyl Saienko | 4ddbeec | 2017-01-20 16:26:04 +0000 | [diff] [blame^] | 21 | # NOTE(vsaienko): concurrent tests work because they are launched in |
| 22 | # separate processes so global variables are not shared among them. |
Yuiko Takada | ff78500 | 2015-12-17 15:56:42 +0900 | [diff] [blame] | 23 | BAREMETAL_MICROVERSION = None |
| 24 | |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 25 | |
Vasyl Saienko | 4ddbeec | 2017-01-20 16:26:04 +0000 | [diff] [blame^] | 26 | def set_baremetal_api_microversion(baremetal_microversion): |
| 27 | global BAREMETAL_MICROVERSION |
| 28 | BAREMETAL_MICROVERSION = baremetal_microversion |
| 29 | |
| 30 | |
| 31 | def reset_baremetal_api_microversion(): |
| 32 | global BAREMETAL_MICROVERSION |
| 33 | BAREMETAL_MICROVERSION = None |
| 34 | |
| 35 | |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 36 | def handle_errors(f): |
| 37 | """A decorator that allows to ignore certain types of errors.""" |
| 38 | |
| 39 | @functools.wraps(f) |
| 40 | def wrapper(*args, **kwargs): |
| 41 | param_name = 'ignore_errors' |
| 42 | ignored_errors = kwargs.get(param_name, tuple()) |
| 43 | |
| 44 | if param_name in kwargs: |
| 45 | del kwargs[param_name] |
| 46 | |
| 47 | try: |
| 48 | return f(*args, **kwargs) |
| 49 | except ignored_errors: |
| 50 | # Silently ignore errors |
| 51 | pass |
| 52 | |
| 53 | return wrapper |
| 54 | |
| 55 | |
| 56 | class BaremetalClient(rest_client.RestClient): |
| 57 | """Base Tempest REST client for Ironic API.""" |
| 58 | |
Yuiko Takada | ff78500 | 2015-12-17 15:56:42 +0900 | [diff] [blame] | 59 | api_microversion_header_name = 'X-OpenStack-Ironic-API-Version' |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 60 | uri_prefix = '' |
| 61 | |
Yuiko Takada | ff78500 | 2015-12-17 15:56:42 +0900 | [diff] [blame] | 62 | def get_headers(self): |
| 63 | headers = super(BaremetalClient, self).get_headers() |
| 64 | if BAREMETAL_MICROVERSION: |
| 65 | headers[self.api_microversion_header_name] = BAREMETAL_MICROVERSION |
| 66 | return headers |
| 67 | |
Vasyl Saienko | f20979c | 2016-05-27 11:25:01 +0300 | [diff] [blame] | 68 | def request(self, *args, **kwargs): |
| 69 | resp, resp_body = super(BaremetalClient, self).request(*args, **kwargs) |
Yuiko Takada | ff78500 | 2015-12-17 15:56:42 +0900 | [diff] [blame] | 70 | if (BAREMETAL_MICROVERSION and |
| 71 | BAREMETAL_MICROVERSION != api_version_utils.LATEST_MICROVERSION): |
| 72 | api_version_utils.assert_version_header_matches_request( |
| 73 | self.api_microversion_header_name, |
| 74 | BAREMETAL_MICROVERSION, |
| 75 | resp) |
| 76 | return resp, resp_body |
| 77 | |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 78 | def serialize(self, object_dict): |
| 79 | """Serialize an Ironic object.""" |
| 80 | |
| 81 | return json.dumps(object_dict) |
| 82 | |
| 83 | def deserialize(self, object_str): |
| 84 | """Deserialize an Ironic object.""" |
| 85 | |
| 86 | return json.loads(object_str) |
| 87 | |
| 88 | def _get_uri(self, resource_name, uuid=None, permanent=False): |
| 89 | """Get URI for a specific resource or object. |
| 90 | |
| 91 | :param resource_name: The name of the REST resource, e.g., 'nodes'. |
| 92 | :param uuid: The unique identifier of an object in UUID format. |
| 93 | :returns: Relative URI for the resource or object. |
| 94 | |
| 95 | """ |
| 96 | prefix = self.uri_prefix if not permanent else '' |
| 97 | |
| 98 | return '{pref}/{res}{uuid}'.format(pref=prefix, |
| 99 | res=resource_name, |
| 100 | uuid='/%s' % uuid if uuid else '') |
| 101 | |
| 102 | def _make_patch(self, allowed_attributes, **kwargs): |
| 103 | """Create a JSON patch according to RFC 6902. |
| 104 | |
| 105 | :param allowed_attributes: An iterable object that contains a set of |
| 106 | allowed attributes for an object. |
| 107 | :param **kwargs: Attributes and new values for them. |
| 108 | :returns: A JSON path that sets values of the specified attributes to |
| 109 | the new ones. |
| 110 | |
| 111 | """ |
| 112 | def get_change(kwargs, path='/'): |
Luong Anh Tuan | e22fbe1 | 2016-09-12 16:32:14 +0700 | [diff] [blame] | 113 | for name, value in kwargs.items(): |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 114 | if isinstance(value, dict): |
| 115 | for ch in get_change(value, path + '%s/' % name): |
| 116 | yield ch |
| 117 | else: |
| 118 | if value is None: |
| 119 | yield {'path': path + name, |
| 120 | 'op': 'remove'} |
| 121 | else: |
| 122 | yield {'path': path + name, |
| 123 | 'value': value, |
| 124 | 'op': 'replace'} |
| 125 | |
| 126 | patch = [ch for ch in get_change(kwargs) |
| 127 | if ch['path'].lstrip('/') in allowed_attributes] |
| 128 | |
| 129 | return patch |
| 130 | |
Sam Betts | 462e9e6 | 2016-11-30 18:43:35 +0000 | [diff] [blame] | 131 | def _list_request(self, resource, permanent=False, headers=None, |
| 132 | extra_headers=False, **kwargs): |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 133 | """Get the list of objects of the specified type. |
| 134 | |
| 135 | :param resource: The name of the REST resource, e.g., 'nodes'. |
Sam Betts | 462e9e6 | 2016-11-30 18:43:35 +0000 | [diff] [blame] | 136 | :param headers: List of headers to use in request. |
| 137 | :param extra_headers: Specify whether to use headers. |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 138 | :param **kwargs: Parameters for the request. |
| 139 | :returns: A tuple with the server response and deserialized JSON list |
| 140 | of objects |
| 141 | |
| 142 | """ |
| 143 | uri = self._get_uri(resource, permanent=permanent) |
| 144 | if kwargs: |
| 145 | uri += "?%s" % urllib.urlencode(kwargs) |
| 146 | |
Sam Betts | 462e9e6 | 2016-11-30 18:43:35 +0000 | [diff] [blame] | 147 | resp, body = self.get(uri, headers=headers, |
| 148 | extra_headers=extra_headers) |
Solio Sarabia | f78122e | 2017-02-23 16:17:34 -0600 | [diff] [blame] | 149 | self.expected_success(http_client.OK, resp.status) |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 150 | |
| 151 | return resp, self.deserialize(body) |
| 152 | |
| 153 | def _show_request(self, resource, uuid, permanent=False, **kwargs): |
| 154 | """Gets a specific object of the specified type. |
| 155 | |
| 156 | :param uuid: Unique identifier of the object in UUID format. |
| 157 | :returns: Serialized object as a dictionary. |
| 158 | |
| 159 | """ |
| 160 | if 'uri' in kwargs: |
| 161 | uri = kwargs['uri'] |
| 162 | else: |
| 163 | uri = self._get_uri(resource, uuid=uuid, permanent=permanent) |
| 164 | resp, body = self.get(uri) |
Solio Sarabia | f78122e | 2017-02-23 16:17:34 -0600 | [diff] [blame] | 165 | self.expected_success(http_client.OK, resp.status) |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 166 | |
| 167 | return resp, self.deserialize(body) |
| 168 | |
| 169 | def _create_request(self, resource, object_dict): |
| 170 | """Create an object of the specified type. |
| 171 | |
| 172 | :param resource: The name of the REST resource, e.g., 'nodes'. |
| 173 | :param object_dict: A Python dict that represents an object of the |
| 174 | specified type. |
| 175 | :returns: A tuple with the server response and the deserialized created |
| 176 | object. |
| 177 | |
| 178 | """ |
| 179 | body = self.serialize(object_dict) |
| 180 | uri = self._get_uri(resource) |
| 181 | |
| 182 | resp, body = self.post(uri, body=body) |
Solio Sarabia | f78122e | 2017-02-23 16:17:34 -0600 | [diff] [blame] | 183 | self.expected_success(http_client.CREATED, resp.status) |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 184 | |
| 185 | return resp, self.deserialize(body) |
| 186 | |
Sam Betts | 462e9e6 | 2016-11-30 18:43:35 +0000 | [diff] [blame] | 187 | def _create_request_no_response_body(self, resource, object_dict): |
| 188 | """Create an object of the specified type. |
| 189 | |
| 190 | Do not expect any body in the response. |
| 191 | |
| 192 | :param resource: The name of the REST resource, e.g., 'nodes'. |
| 193 | :param object_dict: A Python dict that represents an object of the |
| 194 | specified type. |
| 195 | :returns: The server response. |
| 196 | """ |
| 197 | |
| 198 | body = self.serialize(object_dict) |
| 199 | uri = self._get_uri(resource) |
| 200 | |
| 201 | resp, body = self.post(uri, body=body) |
Solio Sarabia | f78122e | 2017-02-23 16:17:34 -0600 | [diff] [blame] | 202 | self.expected_success(http_client.NO_CONTENT, resp.status) |
Sam Betts | 462e9e6 | 2016-11-30 18:43:35 +0000 | [diff] [blame] | 203 | |
| 204 | return resp |
| 205 | |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 206 | def _delete_request(self, resource, uuid): |
| 207 | """Delete specified object. |
| 208 | |
| 209 | :param resource: The name of the REST resource, e.g., 'nodes'. |
| 210 | :param uuid: The unique identifier of an object in UUID format. |
| 211 | :returns: A tuple with the server response and the response body. |
| 212 | |
| 213 | """ |
| 214 | uri = self._get_uri(resource, uuid) |
| 215 | |
| 216 | resp, body = self.delete(uri) |
Solio Sarabia | f78122e | 2017-02-23 16:17:34 -0600 | [diff] [blame] | 217 | self.expected_success(http_client.NO_CONTENT, resp.status) |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 218 | return resp, body |
| 219 | |
| 220 | def _patch_request(self, resource, uuid, patch_object): |
| 221 | """Update specified object with JSON-patch. |
| 222 | |
| 223 | :param resource: The name of the REST resource, e.g., 'nodes'. |
| 224 | :param uuid: The unique identifier of an object in UUID format. |
| 225 | :returns: A tuple with the server response and the serialized patched |
| 226 | object. |
| 227 | |
| 228 | """ |
| 229 | uri = self._get_uri(resource, uuid) |
| 230 | patch_body = json.dumps(patch_object) |
| 231 | |
| 232 | resp, body = self.patch(uri, body=patch_body) |
Solio Sarabia | f78122e | 2017-02-23 16:17:34 -0600 | [diff] [blame] | 233 | self.expected_success(http_client.OK, resp.status) |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 234 | return resp, self.deserialize(body) |
| 235 | |
| 236 | @handle_errors |
| 237 | def get_api_description(self): |
| 238 | """Retrieves all versions of the Ironic API.""" |
| 239 | |
| 240 | return self._list_request('', permanent=True) |
| 241 | |
| 242 | @handle_errors |
| 243 | def get_version_description(self, version='v1'): |
Kyrylo Romanenko | 3600054 | 2016-09-16 15:07:40 +0300 | [diff] [blame] | 244 | """Retrieves the description of the API. |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 245 | |
| 246 | :param version: The version of the API. Default: 'v1'. |
| 247 | :returns: Serialized description of API resources. |
| 248 | |
| 249 | """ |
| 250 | return self._list_request(version, permanent=True) |
| 251 | |
| 252 | def _put_request(self, resource, put_object): |
| 253 | """Update specified object with JSON-patch.""" |
| 254 | uri = self._get_uri(resource) |
| 255 | put_body = json.dumps(put_object) |
| 256 | |
| 257 | resp, body = self.put(uri, body=put_body) |
Solio Sarabia | f78122e | 2017-02-23 16:17:34 -0600 | [diff] [blame] | 258 | self.expected_success([http_client.ACCEPTED, http_client.NO_CONTENT], |
| 259 | resp.status) |
Yuiko Takada | b652700 | 2015-12-07 11:49:12 +0900 | [diff] [blame] | 260 | return resp, body |