ZhiQiang Fan | 39f9722 | 2013-09-20 04:49:44 +0800 | [diff] [blame] | 1 | # Copyright 2012 OpenStack Foundation |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [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 | |
Matthew Treinish | 6421af8 | 2015-04-23 09:47:50 -0400 | [diff] [blame] | 16 | from six.moves import http_client as httplib |
Matthew Treinish | f077dd2 | 2015-04-23 09:37:41 -0400 | [diff] [blame] | 17 | from six.moves.urllib import parse as urlparse |
Daisuke Morita | 2c87d37 | 2013-10-31 19:39:19 +0900 | [diff] [blame] | 18 | |
Ken'ichi Ohmichi | 19f6881 | 2016-03-02 14:09:17 +0900 | [diff] [blame] | 19 | from tempest.lib.common import rest_client |
Brian Ober | f2deb18 | 2016-04-12 19:28:04 +0000 | [diff] [blame] | 20 | from tempest.lib import exceptions |
Matthew Treinish | 684d899 | 2014-01-30 16:27:40 +0000 | [diff] [blame] | 21 | |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 22 | |
Ken'ichi Ohmichi | 19f6881 | 2016-03-02 14:09:17 +0900 | [diff] [blame] | 23 | class ObjectClient(rest_client.RestClient): |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 24 | |
Daisuke Morita | cf6f695 | 2014-03-19 21:25:50 +0900 | [diff] [blame] | 25 | def create_object(self, container, object_name, data, |
Ken'ichi Ohmichi | 179ea57 | 2015-01-01 14:04:49 +0000 | [diff] [blame] | 26 | params=None, metadata=None, headers=None): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 27 | """Create storage object.""" |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 28 | |
Ken'ichi Ohmichi | 179ea57 | 2015-01-01 14:04:49 +0000 | [diff] [blame] | 29 | if headers is None: |
| 30 | headers = self.get_headers() |
Martina Kollarova | 03720a5 | 2013-06-18 15:08:46 +0200 | [diff] [blame] | 31 | if not data: |
| 32 | headers['content-length'] = '0' |
Daisuke Morita | cf6f695 | 2014-03-19 21:25:50 +0900 | [diff] [blame] | 33 | if metadata: |
| 34 | for key in metadata: |
| 35 | headers[str(key)] = metadata[key] |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 36 | url = "%s/%s" % (str(container), str(object_name)) |
Daisuke Morita | 2c87d37 | 2013-10-31 19:39:19 +0900 | [diff] [blame] | 37 | if params: |
Matthew Treinish | 8912814 | 2015-04-23 10:44:30 -0400 | [diff] [blame] | 38 | url += '?%s' % urlparse.urlencode(params) |
Daisuke Morita | 2c87d37 | 2013-10-31 19:39:19 +0900 | [diff] [blame] | 39 | |
Martina Kollarova | 03720a5 | 2013-06-18 15:08:46 +0200 | [diff] [blame] | 40 | resp, body = self.put(url, data, headers) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 41 | self.expected_success(201, resp.status) |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 42 | return resp, body |
| 43 | |
Daisuke Morita | 2c87d37 | 2013-10-31 19:39:19 +0900 | [diff] [blame] | 44 | def delete_object(self, container, object_name, params=None): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 45 | """Delete storage object.""" |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 46 | url = "%s/%s" % (str(container), str(object_name)) |
Daisuke Morita | 2c87d37 | 2013-10-31 19:39:19 +0900 | [diff] [blame] | 47 | if params: |
Matthew Treinish | 8912814 | 2015-04-23 10:44:30 -0400 | [diff] [blame] | 48 | url += '?%s' % urlparse.urlencode(params) |
vponomaryov | 67b58fe | 2014-02-06 19:05:41 +0200 | [diff] [blame] | 49 | resp, body = self.delete(url, headers={}) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 50 | self.expected_success([200, 204], resp.status) |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 51 | return resp, body |
| 52 | |
| 53 | def update_object_metadata(self, container, object_name, metadata, |
| 54 | metadata_prefix='X-Object-Meta-'): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 55 | """Add, remove, or change X-Object-Meta metadata for storage object.""" |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 56 | |
| 57 | headers = {} |
| 58 | for key in metadata: |
| 59 | headers["%s%s" % (str(metadata_prefix), str(key))] = metadata[key] |
| 60 | |
| 61 | url = "%s/%s" % (str(container), str(object_name)) |
| 62 | resp, body = self.post(url, None, headers=headers) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 63 | self.expected_success(202, resp.status) |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 64 | return resp, body |
| 65 | |
| 66 | def list_object_metadata(self, container, object_name): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 67 | """List all storage object X-Object-Meta- metadata.""" |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 68 | |
| 69 | url = "%s/%s" % (str(container), str(object_name)) |
| 70 | resp, body = self.head(url) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 71 | self.expected_success(200, resp.status) |
dwalleck | 5d73443 | 2012-10-04 01:11:47 -0500 | [diff] [blame] | 72 | return resp, body |
Larisa Ustalov | 6c3c780 | 2012-11-05 12:25:19 +0200 | [diff] [blame] | 73 | |
Daisuke Morita | 6d50268 | 2014-03-19 21:08:54 +0900 | [diff] [blame] | 74 | def get_object(self, container, object_name, metadata=None): |
Larisa Ustalov | 6c3c780 | 2012-11-05 12:25:19 +0200 | [diff] [blame] | 75 | """Retrieve object's data.""" |
| 76 | |
Daisuke Morita | 6d50268 | 2014-03-19 21:08:54 +0900 | [diff] [blame] | 77 | headers = {} |
| 78 | if metadata: |
| 79 | for key in metadata: |
| 80 | headers[str(key)] = metadata[key] |
| 81 | |
Larisa Ustalov | 6c3c780 | 2012-11-05 12:25:19 +0200 | [diff] [blame] | 82 | url = "{0}/{1}".format(container, object_name) |
Daisuke Morita | 6d50268 | 2014-03-19 21:08:54 +0900 | [diff] [blame] | 83 | resp, body = self.get(url, headers=headers) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 84 | self.expected_success([200, 206], resp.status) |
Larisa Ustalov | 6c3c780 | 2012-11-05 12:25:19 +0200 | [diff] [blame] | 85 | return resp, body |
| 86 | |
rajalakshmi-ganesan | 925e239 | 2012-11-30 19:17:24 +0530 | [diff] [blame] | 87 | def copy_object_in_same_container(self, container, src_object_name, |
| 88 | dest_object_name, metadata=None): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 89 | """Copy storage object's data to the new object using PUT.""" |
Larisa Ustalov | 6c3c780 | 2012-11-05 12:25:19 +0200 | [diff] [blame] | 90 | |
| 91 | url = "{0}/{1}".format(container, dest_object_name) |
| 92 | headers = {} |
| 93 | headers['X-Copy-From'] = "%s/%s" % (str(container), |
| 94 | str(src_object_name)) |
| 95 | headers['content-length'] = '0' |
| 96 | if metadata: |
| 97 | for key in metadata: |
| 98 | headers[str(key)] = metadata[key] |
| 99 | |
| 100 | resp, body = self.put(url, None, headers=headers) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 101 | self.expected_success(201, resp.status) |
Larisa Ustalov | 6c3c780 | 2012-11-05 12:25:19 +0200 | [diff] [blame] | 102 | return resp, body |
| 103 | |
rajalakshmi-ganesan | 925e239 | 2012-11-30 19:17:24 +0530 | [diff] [blame] | 104 | def copy_object_across_containers(self, src_container, src_object_name, |
| 105 | dst_container, dst_object_name, |
| 106 | metadata=None): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 107 | """Copy storage object's data to the new object using PUT.""" |
rajalakshmi-ganesan | 925e239 | 2012-11-30 19:17:24 +0530 | [diff] [blame] | 108 | |
| 109 | url = "{0}/{1}".format(dst_container, dst_object_name) |
| 110 | headers = {} |
| 111 | headers['X-Copy-From'] = "%s/%s" % (str(src_container), |
| 112 | str(src_object_name)) |
| 113 | headers['content-length'] = '0' |
| 114 | if metadata: |
| 115 | for key in metadata: |
| 116 | headers[str(key)] = metadata[key] |
| 117 | |
| 118 | resp, body = self.put(url, None, headers=headers) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 119 | self.expected_success(201, resp.status) |
rajalakshmi-ganesan | 925e239 | 2012-11-30 19:17:24 +0530 | [diff] [blame] | 120 | return resp, body |
| 121 | |
Larisa Ustalov | 6c3c780 | 2012-11-05 12:25:19 +0200 | [diff] [blame] | 122 | def copy_object_2d_way(self, container, src_object_name, dest_object_name, |
| 123 | metadata=None): |
Sean Dague | f237ccb | 2013-01-04 15:19:14 -0500 | [diff] [blame] | 124 | """Copy storage object's data to the new object using COPY.""" |
Larisa Ustalov | 6c3c780 | 2012-11-05 12:25:19 +0200 | [diff] [blame] | 125 | |
| 126 | url = "{0}/{1}".format(container, src_object_name) |
| 127 | headers = {} |
| 128 | headers['Destination'] = "%s/%s" % (str(container), |
| 129 | str(dest_object_name)) |
| 130 | if metadata: |
| 131 | for key in metadata: |
| 132 | headers[str(key)] = metadata[key] |
| 133 | |
| 134 | resp, body = self.copy(url, headers=headers) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 135 | self.expected_success(201, resp.status) |
Larisa Ustalov | 6c3c780 | 2012-11-05 12:25:19 +0200 | [diff] [blame] | 136 | return resp, body |
harika-vakadi | 1a9ad61 | 2012-12-14 19:12:08 +0530 | [diff] [blame] | 137 | |
harika-vakadi | 7cfc518 | 2013-01-16 13:59:25 +0530 | [diff] [blame] | 138 | def create_object_segments(self, container, object_name, segment, data): |
| 139 | """Creates object segments.""" |
| 140 | url = "{0}/{1}/{2}".format(container, object_name, segment) |
Valeriy Ponomaryov | 88686d8 | 2014-02-16 12:24:51 +0200 | [diff] [blame] | 141 | resp, body = self.put(url, data) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 142 | self.expected_success(201, resp.status) |
ravikumar-venkatesan | e43b77a | 2013-01-09 07:27:13 +0000 | [diff] [blame] | 143 | return resp, body |
| 144 | |
Jordan Pittier | 4408c4a | 2016-04-29 15:05:09 +0200 | [diff] [blame] | 145 | def put_object_with_chunk(self, container, name, contents): |
| 146 | """Put an object with Transfer-Encoding header |
| 147 | |
| 148 | :param container: name of the container |
| 149 | :type container: string |
| 150 | :param name: name of the object |
| 151 | :type name: string |
| 152 | :param contents: object data |
| 153 | :type contents: iterable |
| 154 | """ |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 155 | headers = {'Transfer-Encoding': 'chunked'} |
| 156 | if self.token: |
| 157 | headers['X-Auth-Token'] = self.token |
| 158 | |
Jordan Pittier | 4408c4a | 2016-04-29 15:05:09 +0200 | [diff] [blame] | 159 | url = "%s/%s" % (container, name) |
| 160 | resp, body = self.put( |
| 161 | url, headers=headers, |
| 162 | body=contents, |
| 163 | chunked=True |
| 164 | ) |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 165 | |
Ken'ichi Ohmichi | 17051e8 | 2016-10-20 11:46:06 -0700 | [diff] [blame] | 166 | self._error_checker(resp, body) |
JordanP | a84dde3 | 2014-11-14 15:47:42 +0100 | [diff] [blame] | 167 | self.expected_success(201, resp.status) |
Jordan Pittier | 4408c4a | 2016-04-29 15:05:09 +0200 | [diff] [blame] | 168 | return resp.status, resp.reason, resp |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 169 | |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 170 | def create_object_continue(self, container, object_name, |
| 171 | data, metadata=None): |
Brian Ober | f2deb18 | 2016-04-12 19:28:04 +0000 | [diff] [blame] | 172 | """Put an object using Expect:100-continue""" |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 173 | headers = {} |
| 174 | if metadata: |
| 175 | for key in metadata: |
| 176 | headers[str(key)] = metadata[key] |
| 177 | |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 178 | headers['X-Auth-Token'] = self.token |
Brian Ober | f2deb18 | 2016-04-12 19:28:04 +0000 | [diff] [blame] | 179 | headers['content-length'] = 0 if data is None else len(data) |
| 180 | headers['Expect'] = '100-continue' |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 181 | |
Brian Ober | f2deb18 | 2016-04-12 19:28:04 +0000 | [diff] [blame] | 182 | parsed = urlparse.urlparse(self.base_url) |
| 183 | path = str(parsed.path) + "/" |
| 184 | path += "%s/%s" % (str(container), str(object_name)) |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 185 | |
Brian Ober | f2deb18 | 2016-04-12 19:28:04 +0000 | [diff] [blame] | 186 | conn = create_connection(parsed) |
| 187 | |
| 188 | # Send the PUT request and the headers including the "Expect" header |
| 189 | conn.putrequest('PUT', path) |
| 190 | |
guo yunxian | 7bbbec1 | 2016-08-21 20:03:10 +0800 | [diff] [blame] | 191 | for header, value in headers.items(): |
Brian Ober | f2deb18 | 2016-04-12 19:28:04 +0000 | [diff] [blame] | 192 | conn.putheader(header, value) |
| 193 | conn.endheaders() |
| 194 | |
| 195 | # Read the 100 status prior to sending the data |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 196 | response = conn.response_class(conn.sock, |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 197 | method=conn._method) |
Brian Ober | f2deb18 | 2016-04-12 19:28:04 +0000 | [diff] [blame] | 198 | _, status, _ = response._read_status() |
Daisuke Morita | 02f840b | 2014-03-19 20:51:01 +0900 | [diff] [blame] | 199 | |
Brian Ober | f2deb18 | 2016-04-12 19:28:04 +0000 | [diff] [blame] | 200 | # toss the CRLF at the end of the response |
| 201 | response._safe_read(2) |
| 202 | |
| 203 | # Expecting a 100 here, if not close and throw an exception |
| 204 | if status != 100: |
| 205 | conn.close() |
| 206 | pattern = "%s %s" % ( |
| 207 | """Unexpected http success status code {0}.""", |
| 208 | """The expected status code is {1}""") |
| 209 | details = pattern.format(status, 100) |
| 210 | raise exceptions.UnexpectedResponseCode(details) |
| 211 | |
| 212 | # If a continue was received go ahead and send the data |
| 213 | # and get the final response |
| 214 | conn.send(data) |
| 215 | |
| 216 | resp = conn.getresponse() |
| 217 | |
| 218 | return resp.status, resp.reason |
| 219 | |
| 220 | |
| 221 | def create_connection(parsed_url): |
| 222 | """Helper function to create connection with httplib |
| 223 | |
| 224 | :param parsed_url: parsed url of the remote location |
| 225 | """ |
| 226 | if parsed_url.scheme == 'https': |
| 227 | conn = httplib.HTTPSConnection(parsed_url.netloc) |
| 228 | else: |
| 229 | conn = httplib.HTTPConnection(parsed_url.netloc) |
| 230 | |
| 231 | return conn |