← Back to branch summary

~ubuntu-branches/ubuntu/quantal/keystone/quantal-security

« back to all changes in this revision

Viewing changes to keystone/contrib/admin_crud/core.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-06-22 12:27:50 UTC
  • mto: (35.1.1 quantal-proposed)
  • mto: This revision was merged to the branch mainline in revision 28.
  • Revision ID: package-import@ubuntu.com-20120622122750-4urdq17en1990apn
Tags: upstream-2012.2~f2~20120622.2353
Import upstream version 2012.2~f2~20120622.2353

Show diffs side-by-side

added added

removed removed

Lines of Context:
keystone/contrib/admin_crud/core.py
15
15
# under the License.
16
16
 
17
17
from keystone import catalog
 
18
from keystone.common import wsgi
18
19
from keystone import identity
19
 
from keystone.common import wsgi
20
20
 
21
21
 
22
22
class CrudExtension(wsgi.ExtensionRouter):
34
34
        endpoint_controller = catalog.EndpointController()
35
35
 
36
36
        # Tenant Operations
37
 
        mapper.connect('/tenants', controller=tenant_controller,
38
 
                    action='create_tenant',
39
 
                    conditions=dict(method=['POST']))
40
 
        mapper.connect('/tenants/{tenant_id}',
41
 
                    controller=tenant_controller,
42
 
                    action='update_tenant',
43
 
                    conditions=dict(method=['PUT', 'POST']))
44
 
        mapper.connect('/tenants/{tenant_id}',
45
 
                    controller=tenant_controller,
46
 
                    action='delete_tenant',
47
 
                    conditions=dict(method=['DELETE']))
48
 
        mapper.connect('/tenants/{tenant_id}/users',
49
 
                    controller=tenant_controller,
50
 
                    action='get_tenant_users',
51
 
                    conditions=dict(method=['GET']))
 
37
        mapper.connect(
 
38
            '/tenants',
 
39
            controller=tenant_controller,
 
40
            action='create_tenant',
 
41
            conditions=dict(method=['POST']))
 
42
        mapper.connect(
 
43
            '/tenants/{tenant_id}',
 
44
            controller=tenant_controller,
 
45
            action='update_tenant',
 
46
            conditions=dict(method=['PUT', 'POST']))
 
47
        mapper.connect(
 
48
            '/tenants/{tenant_id}',
 
49
            controller=tenant_controller,
 
50
            action='delete_tenant',
 
51
            conditions=dict(method=['DELETE']))
 
52
        mapper.connect(
 
53
            '/tenants/{tenant_id}/users',
 
54
            controller=tenant_controller,
 
55
            action='get_tenant_users',
 
56
            conditions=dict(method=['GET']))
52
57
 
53
58
        # User Operations
54
 
        mapper.connect('/users',
55
 
                    controller=user_controller,
56
 
                    action='get_users',
57
 
                    conditions=dict(method=['GET']))
58
 
        mapper.connect('/users',
59
 
                    controller=user_controller,
60
 
                    action='create_user',
61
 
                    conditions=dict(method=['POST']))
 
59
        mapper.connect(
 
60
            '/users',
 
61
            controller=user_controller,
 
62
            action='get_users',
 
63
            conditions=dict(method=['GET']))
 
64
        mapper.connect(
 
65
            '/users',
 
66
            controller=user_controller,
 
67
            action='create_user',
 
68
            conditions=dict(method=['POST']))
62
69
        # NOTE(termie): not in diablo
63
 
        mapper.connect('/users/{user_id}',
64
 
                    controller=user_controller,
65
 
                    action='update_user',
66
 
                    conditions=dict(method=['PUT']))
67
 
        mapper.connect('/users/{user_id}',
68
 
                    controller=user_controller,
69
 
                    action='delete_user',
70
 
                    conditions=dict(method=['DELETE']))
71
 
 
72
 
        # COMPAT(diablo): the copy with no OS-KSADM is from diablo
73
 
        mapper.connect('/users/{user_id}/password',
74
 
                    controller=user_controller,
75
 
                    action='set_user_password',
76
 
                    conditions=dict(method=['PUT']))
77
 
        mapper.connect('/users/{user_id}/OS-KSADM/password',
78
 
                    controller=user_controller,
79
 
                    action='set_user_password',
80
 
                    conditions=dict(method=['PUT']))
81
 
 
82
 
        # COMPAT(diablo): the copy with no OS-KSADM is from diablo
83
 
        mapper.connect('/users/{user_id}/tenant',
84
 
                    controller=user_controller,
85
 
                    action='update_user_tenant',
86
 
                    conditions=dict(method=['PUT']))
87
 
        mapper.connect('/users/{user_id}/OS-KSADM/tenant',
88
 
                    controller=user_controller,
89
 
                    action='update_user_tenant',
90
 
                    conditions=dict(method=['PUT']))
91
 
 
92
 
        # COMPAT(diablo): the copy with no OS-KSADM is from diablo
93
 
        mapper.connect('/users/{user_id}/enabled',
94
 
                    controller=user_controller,
95
 
                    action='set_user_enabled',
96
 
                    conditions=dict(method=['PUT']))
97
 
        mapper.connect('/users/{user_id}/OS-KSADM/enabled',
98
 
                    controller=user_controller,
99
 
                    action='set_user_enabled',
100
 
                    conditions=dict(method=['PUT']))
 
70
        mapper.connect(
 
71
            '/users/{user_id}',
 
72
            controller=user_controller,
 
73
            action='update_user',
 
74
            conditions=dict(method=['PUT']))
 
75
        mapper.connect(
 
76
            '/users/{user_id}',
 
77
            controller=user_controller,
 
78
            action='delete_user',
 
79
            conditions=dict(method=['DELETE']))
 
80
 
 
81
        # COMPAT(diablo): the copy with no OS-KSADM is from diablo
 
82
        mapper.connect(
 
83
            '/users/{user_id}/password',
 
84
            controller=user_controller,
 
85
            action='set_user_password',
 
86
            conditions=dict(method=['PUT']))
 
87
        mapper.connect(
 
88
            '/users/{user_id}/OS-KSADM/password',
 
89
            controller=user_controller,
 
90
            action='set_user_password',
 
91
            conditions=dict(method=['PUT']))
 
92
 
 
93
        # COMPAT(diablo): the copy with no OS-KSADM is from diablo
 
94
        mapper.connect(
 
95
            '/users/{user_id}/tenant',
 
96
            controller=user_controller,
 
97
            action='update_user_tenant',
 
98
            conditions=dict(method=['PUT']))
 
99
        mapper.connect(
 
100
            '/users/{user_id}/OS-KSADM/tenant',
 
101
            controller=user_controller,
 
102
            action='update_user_tenant',
 
103
            conditions=dict(method=['PUT']))
 
104
 
 
105
        # COMPAT(diablo): the copy with no OS-KSADM is from diablo
 
106
        mapper.connect(
 
107
            '/users/{user_id}/enabled',
 
108
            controller=user_controller,
 
109
            action='set_user_enabled',
 
110
            conditions=dict(method=['PUT']))
 
111
        mapper.connect(
 
112
            '/users/{user_id}/OS-KSADM/enabled',
 
113
            controller=user_controller,
 
114
            action='set_user_enabled',
 
115
            conditions=dict(method=['PUT']))
101
116
 
102
117
        # User Roles
103
 
        mapper.connect('/users/{user_id}/roles/OS-KSADM/{role_id}',
104
 
            controller=role_controller, action='add_role_to_user',
 
118
        mapper.connect(
 
119
            '/users/{user_id}/roles/OS-KSADM/{role_id}',
 
120
            controller=role_controller,
 
121
            action='add_role_to_user',
105
122
            conditions=dict(method=['PUT']))
106
 
        mapper.connect('/users/{user_id}/roles/OS-KSADM/{role_id}',
107
 
            controller=role_controller, action='delete_role_from_user',
 
123
        mapper.connect(
 
124
            '/users/{user_id}/roles/OS-KSADM/{role_id}',
 
125
            controller=role_controller,
 
126
            action='delete_role_from_user',
108
127
            conditions=dict(method=['DELETE']))
109
128
 
110
129
        # COMPAT(diablo): User Roles
111
 
        mapper.connect('/users/{user_id}/roleRefs',
112
 
            controller=role_controller, action='get_role_refs',
 
130
        mapper.connect(
 
131
            '/users/{user_id}/roleRefs',
 
132
            controller=role_controller,
 
133
            action='get_role_refs',
113
134
            conditions=dict(method=['GET']))
114
 
        mapper.connect('/users/{user_id}/roleRefs',
115
 
            controller=role_controller, action='create_role_ref',
 
135
        mapper.connect(
 
136
            '/users/{user_id}/roleRefs',
 
137
            controller=role_controller,
 
138
            action='create_role_ref',
116
139
            conditions=dict(method=['POST']))
117
 
        mapper.connect('/users/{user_id}/roleRefs/{role_ref_id}',
118
 
            controller=role_controller, action='delete_role_ref',
 
140
        mapper.connect(
 
141
            '/users/{user_id}/roleRefs/{role_ref_id}',
 
142
            controller=role_controller,
 
143
            action='delete_role_ref',
119
144
            conditions=dict(method=['DELETE']))
120
145
 
121
146
        # User-Tenant Roles
122
147
        mapper.connect(
123
148
            '/tenants/{tenant_id}/users/{user_id}/roles/OS-KSADM/{role_id}',
124
 
            controller=role_controller, action='add_role_to_user',
 
149
            controller=role_controller,
 
150
            action='add_role_to_user',
125
151
            conditions=dict(method=['PUT']))
126
152
        mapper.connect(
127
153
            '/tenants/{tenant_id}/users/{user_id}/roles/OS-KSADM/{role_id}',
128
 
            controller=role_controller, action='remove_role_from_user',
 
154
            controller=role_controller,
 
155
            action='remove_role_from_user',
129
156
            conditions=dict(method=['DELETE']))
130
157
 
131
158
        # Service Operations
132
 
        mapper.connect('/OS-KSADM/services',
133
 
                       controller=service_controller,
134
 
                       action='get_services',
135
 
                       conditions=dict(method=['GET']))
136
 
        mapper.connect('/OS-KSADM/services',
137
 
                       controller=service_controller,
138
 
                       action='create_service',
139
 
                       conditions=dict(method=['POST']))
140
 
        mapper.connect('/OS-KSADM/services/{service_id}',
141
 
                       controller=service_controller,
142
 
                       action='delete_service',
143
 
                       conditions=dict(method=['DELETE']))
144
 
        mapper.connect('/OS-KSADM/services/{service_id}',
145
 
                       controller=service_controller,
146
 
                       action='get_service',
147
 
                       conditions=dict(method=['GET']))
 
159
        mapper.connect(
 
160
            '/OS-KSADM/services',
 
161
            controller=service_controller,
 
162
            action='get_services',
 
163
            conditions=dict(method=['GET']))
 
164
        mapper.connect(
 
165
            '/OS-KSADM/services',
 
166
            controller=service_controller,
 
167
            action='create_service',
 
168
            conditions=dict(method=['POST']))
 
169
        mapper.connect(
 
170
            '/OS-KSADM/services/{service_id}',
 
171
            controller=service_controller,
 
172
            action='delete_service',
 
173
            conditions=dict(method=['DELETE']))
 
174
        mapper.connect(
 
175
            '/OS-KSADM/services/{service_id}',
 
176
            controller=service_controller,
 
177
            action='get_service',
 
178
            conditions=dict(method=['GET']))
148
179
 
149
180
        # Endpoint Templates
150
 
        mapper.connect('/endpoints',
151
 
                       controller=endpoint_controller,
152
 
                       action='get_endpoints',
153
 
                       conditions=dict(method=['GET']))
154
 
        mapper.connect('/endpoints',
155
 
                       controller=endpoint_controller,
156
 
                       action='create_endpoint',
157
 
                       conditions=dict(method=['POST']))
158
 
        mapper.connect('/endpoints/{endpoint_id}',
159
 
                       controller=endpoint_controller,
160
 
                       action='delete_endpoint',
161
 
                       conditions=dict(method=['DELETE']))
 
181
        mapper.connect(
 
182
            '/endpoints',
 
183
            controller=endpoint_controller,
 
184
            action='get_endpoints',
 
185
            conditions=dict(method=['GET']))
 
186
        mapper.connect(
 
187
            '/endpoints',
 
188
            controller=endpoint_controller,
 
189
            action='create_endpoint',
 
190
            conditions=dict(method=['POST']))
 
191
        mapper.connect(
 
192
            '/endpoints/{endpoint_id}',
 
193
            controller=endpoint_controller,
 
194
            action='delete_endpoint',
 
195
            conditions=dict(method=['DELETE']))
162
196
 
163
197
        # Role Operations
164
 
        mapper.connect('/OS-KSADM/roles',
165
 
                       controller=role_controller,
166
 
                       action='create_role',
167
 
                       conditions=dict(method=['POST']))
168
 
        mapper.connect('/OS-KSADM/roles',
169
 
                       controller=role_controller,
170
 
                       action='get_roles',
171
 
                       conditions=dict(method=['GET']))
172
 
        mapper.connect('/OS-KSADM/roles/{role_id}',
173
 
                       controller=role_controller,
174
 
                       action='get_role',
175
 
                       conditions=dict(method=['GET']))
176
 
        mapper.connect('/OS-KSADM/roles/{role_id}',
177
 
                       controller=role_controller,
178
 
                       action='delete_role',
179
 
                       conditions=dict(method=['DELETE']))
 
198
        mapper.connect(
 
199
            '/OS-KSADM/roles',
 
200
            controller=role_controller,
 
201
            action='create_role',
 
202
            conditions=dict(method=['POST']))
 
203
        mapper.connect(
 
204
            '/OS-KSADM/roles',
 
205
            controller=role_controller,
 
206
            action='get_roles',
 
207
            conditions=dict(method=['GET']))
 
208
        mapper.connect(
 
209
            '/OS-KSADM/roles/{role_id}',
 
210
            controller=role_controller,
 
211
            action='get_role',
 
212
            conditions=dict(method=['GET']))
 
213
        mapper.connect(
 
214
            '/OS-KSADM/roles/{role_id}',
 
215
            controller=role_controller,
 
216
            action='delete_role',
 
217
            conditions=dict(method=['DELETE']))