1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from openstack import exceptions
from openstack import resource
class Limit(resource.Resource):
resource_key = 'limit'
resources_key = 'limits'
base_path = '/limits'
# capabilities
allow_create = True
allow_fetch = True
allow_commit = True
allow_delete = True
allow_list = True
commit_method = 'PATCH'
commit_jsonpatch = True
_query_mapping = resource.QueryParameters(
'service_id', 'region_id', 'resource_name', 'project_id'
)
# Properties
#: User-facing description of the registered_limit. *Type: string*
description = resource.Body('description')
#: The links for the registered_limit resource.
links = resource.Body('links')
#: ID of service. *Type: string*
service_id = resource.Body('service_id')
#: ID of region, if any. *Type: string*
region_id = resource.Body('region_id')
#: The resource name. *Type: string*
resource_name = resource.Body('resource_name')
#: The resource limit value. *Type: int*
resource_limit = resource.Body('resource_limit')
#: ID of project. *Type: string*
project_id = resource.Body('project_id')
def _prepare_request_body(
self,
patch,
prepend_key,
*,
resource_request_key=None,
):
body = self._body.dirty
if prepend_key and self.resource_key is not None:
if patch:
body = {self.resource_key: body}
else:
# Keystone support bunch create for unified limit. So the
# request body for creating limit is a list instead of dict.
body = {self.resources_key: [body]}
return body
def _translate_response(
self,
response,
has_body=None,
error_message=None,
*,
resource_response_key='limits',
):
"""Given a KSA response, inflate this instance with its data
DELETE operations don't return a body, so only try to work
with a body when has_body is True.
This method updates attributes that correspond to headers
and body on this instance and clears the dirty set.
"""
if has_body is None:
has_body = self.has_body
exceptions.raise_from_response(response, error_message=error_message)
if has_body:
try:
body = response.json()
if resource_response_key and resource_response_key in body:
body = body[resource_response_key]
elif self.resource_key and self.resource_key in body:
body = body[self.resource_key]
# Keystone support bunch create for unified limit. So the
# response body for creating limit is a list instead of dict.
if isinstance(body, list):
body = body[0]
# Do not allow keys called "self" through. Glance chose
# to name a key "self", so we need to pop it out because
# we can't send it through cls.existing and into the
# Resource initializer. "self" is already the first
# argument and is practically a reserved word.
body.pop("self", None)
body_attrs = self._consume_body_attrs(body)
if self._allow_unknown_attrs_in_body:
body_attrs.update(body)
self._unknown_attrs_in_body.update(body)
elif self._store_unknown_attrs_as_properties:
body_attrs = self._pack_attrs_under_properties(
body_attrs, body
)
self._body.attributes.update(body_attrs)
self._body.clean()
if self.commit_jsonpatch or self.allow_patch:
# We need the original body to compare against
self._original_body = body_attrs.copy()
except ValueError:
# Server returned not parse-able response (202, 204, etc)
# Do simply nothing
pass
headers = self._consume_header_attrs(response.headers)
self._header.attributes.update(headers)
self._header.clean()
self._update_location()
dict.update(self, self.to_dict())
|
