← Back to branch summary

~ubuntu-branches/ubuntu/saucy/keystone/saucy-proposed

« back to all changes in this revision

Viewing changes to keystone/routers/admin.py

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2011-08-23 10:18:22 UTC
  • Revision ID: james.westby@ubuntu.com-20110823101822-enve6zceb3lqhuvj
Tags: upstream-1.0~d4~20110823.1078
Import upstream version 1.0~d4~20110823.1078

Show diffs side-by-side

added added

removed removed

Lines of Context:
keystone/routers/admin.py
 
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
 
2
 
 
3
# Copyright 2010 OpenStack LLC.
 
4
# All Rights Reserved.
 
5
#
 
6
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
 
7
#    not use this file except in compliance with the License. You may obtain
 
8
#    a copy of the License at
 
9
#
 
10
#         http://www.apache.org/licenses/LICENSE-2.0
 
11
#
 
12
#    Unless required by applicable law or agreed to in writing, software
 
13
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 
14
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
15
#    License for the specific language governing permissions and limitations
 
16
#    under the License.
 
17
 
 
18
import routes
 
19
 
 
20
from keystone.common import wsgi
 
21
import keystone.backends as db
 
22
from keystone.controllers.auth import AuthController
 
23
from keystone.controllers.endpointtemplates import EndpointTemplatesController
 
24
from keystone.controllers.roles import RolesController
 
25
from keystone.controllers.services import ServicesController
 
26
from keystone.controllers.staticfiles import StaticFilesController
 
27
from keystone.controllers.tenant import TenantController
 
28
from keystone.controllers.user import UserController
 
29
from keystone.controllers.version import VersionController
 
30
from keystone.controllers.extensions import ExtensionsController
 
31
 
 
32
 
 
33
class AdminApi(wsgi.Router):
 
34
    """WSGI entry point for admin Keystone API requests."""
 
35
 
 
36
    def __init__(self, options):
 
37
        self.options = options
 
38
        mapper = routes.Mapper()
 
39
        db.configure_backends(options)
 
40
 
 
41
        # Token Operations
 
42
        auth_controller = AuthController(options)
 
43
        mapper.connect("/tokens", controller=auth_controller,
 
44
                       action="authenticate",
 
45
                       conditions=dict(method=["POST"]))
 
46
        mapper.connect("/tokens/{token_id}", controller=auth_controller,
 
47
                        action="validate_token",
 
48
                        conditions=dict(method=["GET"]))
 
49
        mapper.connect("/tokens/{token_id}", controller=auth_controller,
 
50
                        action="delete_token",
 
51
                        conditions=dict(method=["DELETE"]))
 
52
 
 
53
        # Tenant Operations
 
54
        tenant_controller = TenantController(options)
 
55
        mapper.connect("/tenants", controller=tenant_controller,
 
56
                    action="create_tenant",
 
57
                    conditions=dict(method=["PUT", "POST"]))
 
58
        mapper.connect("/tenants", controller=tenant_controller,
 
59
                    action="get_tenants", conditions=dict(method=["GET"]))
 
60
        mapper.connect("/tenants/{tenant_id}",
 
61
                    controller=tenant_controller,
 
62
                    action="get_tenant", conditions=dict(method=["GET"]))
 
63
        mapper.connect("/tenants/{tenant_id}",
 
64
                    controller=tenant_controller,
 
65
                    action="update_tenant", conditions=dict(method=["PUT"]))
 
66
        mapper.connect("/tenants/{tenant_id}",
 
67
                    controller=tenant_controller,
 
68
                    action="delete_tenant", conditions=dict(method=["DELETE"]))
 
69
 
 
70
        # User Operations
 
71
        user_controller = UserController(options)
 
72
        mapper.connect("/users",
 
73
                    controller=user_controller,
 
74
                    action="create_user",
 
75
                    conditions=dict(method=["PUT", "POST"]))
 
76
        mapper.connect("/users",
 
77
                    controller=user_controller,
 
78
                    action="get_users",
 
79
                    conditions=dict(method=["GET"]))
 
80
        mapper.connect("/users/{user_id}",
 
81
                    controller=user_controller,
 
82
                    action="get_user",
 
83
                    conditions=dict(method=["GET"]))
 
84
        mapper.connect("/users/{user_id}",
 
85
                    controller=user_controller,
 
86
                    action="update_user",
 
87
                    conditions=dict(method=["PUT"]))
 
88
        mapper.connect("/users/{user_id}",
 
89
                    controller=user_controller,
 
90
                    action="delete_user",
 
91
                    conditions=dict(method=["DELETE"]))
 
92
        mapper.connect("/users/{user_id}/password",
 
93
                    controller=user_controller,
 
94
                    action="set_user_password",
 
95
                    conditions=dict(method=["PUT"]))
 
96
        mapper.connect("/users/{user_id}/tenant",
 
97
                    controller=user_controller,
 
98
                    action="update_user_tenant",
 
99
                    conditions=dict(method=["PUT"]))
 
100
        # Test this, test failed
 
101
        mapper.connect("/users/{user_id}/enabled",
 
102
                    controller=user_controller,
 
103
                    action="set_user_enabled",
 
104
                    conditions=dict(method=["PUT"]))
 
105
        mapper.connect("/tenants/{tenant_id}/users",
 
106
                    controller=user_controller,
 
107
                    action="get_tenant_users",
 
108
                    conditions=dict(method=["GET"]))
 
109
 
 
110
        #Roles
 
111
        roles_controller = RolesController(options)
 
112
        mapper.connect("/roles", controller=roles_controller,
 
113
                    action="create_role", conditions=dict(method=["POST"]))
 
114
        mapper.connect("/roles", controller=roles_controller,
 
115
                    action="get_roles", conditions=dict(method=["GET"]))
 
116
        mapper.connect("/roles/{role_id}", controller=roles_controller,
 
117
                    action="get_role", conditions=dict(method=["GET"]))
 
118
        mapper.connect("/roles/{role_id}", controller=roles_controller,
 
119
            action="delete_role", conditions=dict(method=["DELETE"]))
 
120
        mapper.connect("/users/{user_id}/roleRefs",
 
121
            controller=roles_controller, action="get_role_refs",
 
122
            conditions=dict(method=["GET"]))
 
123
        mapper.connect("/users/{user_id}/roleRefs",
 
124
            controller=roles_controller, action="create_role_ref",
 
125
            conditions=dict(method=["POST"]))
 
126
        mapper.connect("/users/{user_id}/roleRefs/{role_ref_id}",
 
127
            controller=roles_controller, action="delete_role_ref",
 
128
            conditions=dict(method=["DELETE"]))
 
129
 
 
130
        #EndpointTemplatesControllers and Endpoints
 
131
        endpoint_templates_controller = EndpointTemplatesController(options)
 
132
        mapper.connect("/endpointTemplates",
 
133
            controller=endpoint_templates_controller,
 
134
                action="get_endpoint_templates",
 
135
                    conditions=dict(method=["GET"]))
 
136
        mapper.connect("/endpointTemplates",
 
137
            controller=endpoint_templates_controller,
 
138
                action="add_endpoint_template",
 
139
                    conditions=dict(method=["POST"]))
 
140
        mapper.connect("/endpointTemplates/{endpoint_templates_id}",
 
141
                controller=endpoint_templates_controller,
 
142
                    action="get_endpoint_template",
 
143
                        conditions=dict(method=["GET"]))
 
144
        mapper.connect("/endpointTemplates/{endpoint_templates_id}",
 
145
                controller=endpoint_templates_controller,
 
146
                    action="modify_endpoint_template",
 
147
                        conditions=dict(method=["PUT"]))
 
148
        mapper.connect("/endpointTemplates/{endpoint_templates_id}",
 
149
                controller=endpoint_templates_controller,
 
150
                    action="delete_endpoint_template",
 
151
                        conditions=dict(method=["DELETE"]))
 
152
        mapper.connect("/tenants/{tenant_id}/endpoints",
 
153
                       controller=endpoint_templates_controller,
 
154
                    action="get_endpoints_for_tenant",
 
155
                    conditions=dict(method=["GET"]))
 
156
        mapper.connect("/tenants/{tenant_id}/endpoints",
 
157
                       controller=endpoint_templates_controller,
 
158
                     action="add_endpoint_to_tenant",
 
159
                     conditions=dict(method=["POST"]))
 
160
        mapper.connect(
 
161
                "/tenants/{tenant_id}/endpoints/{endpoints_id}",
 
162
                controller=endpoint_templates_controller,
 
163
                action="remove_endpoint_from_tenant",
 
164
                conditions=dict(method=["DELETE"]))
 
165
 
 
166
        # Miscellaneous Operations
 
167
        version_controller = VersionController(options)
 
168
        mapper.connect("/", controller=version_controller,
 
169
                    action="get_version_info", file="admin/version",
 
170
                    conditions=dict(method=["GET"]))
 
171
 
 
172
        extensions_controller = ExtensionsController(options)
 
173
        mapper.connect("/extensions",
 
174
                        controller=extensions_controller,
 
175
                        action="get_extensions_info",
 
176
                        path="content/admin/extensions",
 
177
                        conditions=dict(method=["GET"]))
 
178
 
 
179
        # Static Files Controller
 
180
        static_files_controller = StaticFilesController(options)
 
181
        mapper.connect("/identityadminguide.pdf",
 
182
                    controller=static_files_controller,
 
183
                    action="get_pdf_contract",
 
184
                    root="content/admin/", pdf="identityadminguide.pdf",
 
185
                    conditions=dict(method=["GET"]))
 
186
        mapper.connect("/identity-admin.wadl",
 
187
                    controller=static_files_controller,
 
188
                    action="get_wadl_contract",
 
189
                    root="content/admin/", wadl="identity-admin.wadl",
 
190
                    conditions=dict(method=["GET"]))
 
191
        mapper.connect("/common.ent",
 
192
                    controller=static_files_controller,
 
193
                    action="get_wadl_contract",
 
194
                    root="content/common/", wadl="common.ent",
 
195
                    conditions=dict(method=["GET"]))
 
196
        mapper.connect("/xsd/{xsd}",
 
197
                    controller=static_files_controller,
 
198
                    action="get_xsd_contract",
 
199
                    root="content/admin/",
 
200
                    conditions=dict(method=["GET"]))
 
201
        mapper.connect("/xsd/atom/{xsd}",
 
202
                    controller=static_files_controller,
 
203
                    action="get_xsd_atom_contract",
 
204
                    root="content/admin/",
 
205
                    conditions=dict(method=["GET"]))
 
206
        mapper.connect("/xslt/{file:.*}",
 
207
                    controller=static_files_controller,
 
208
                    action="get_static_file",
 
209
                    root="content/common/", path="xslt/",
 
210
                    mimetype="application/xml",
 
211
                    conditions=dict(method=["GET"]))
 
212
        mapper.connect("/js/{file:.*}",
 
213
                    controller=static_files_controller,
 
214
                    action="get_static_file",
 
215
                    root="content/common/", path="js/",
 
216
                    mimetype="application/javascript",
 
217
                    conditions=dict(method=["GET"]))
 
218
        mapper.connect("/style/{file:.*}",
 
219
                    controller=static_files_controller,
 
220
                    action="get_static_file",
 
221
                    root="content/common/", path="style/",
 
222
                    mimetype="application/css",
 
223
                    conditions=dict(method=["GET"]))
 
224
        mapper.connect("/samples/{file:.*}",
 
225
                    controller=static_files_controller,
 
226
                    action="get_static_file",
 
227
                    root="content/common/", path="samples/",
 
228
                    conditions=dict(method=["GET"]))
 
229
 
 
230
        # Services Controller
 
231
        services_controller = ServicesController(options)
 
232
        mapper.connect("/services",
 
233
                    controller=services_controller,
 
234
                    action="get_services",
 
235
                    conditions=dict(method=["GET"]))
 
236
        mapper.connect("/services",
 
237
                    controller=services_controller,
 
238
                    action="create_service",
 
239
                    conditions=dict(method=["POST"]))
 
240
        mapper.connect("/services/{service_id}",
 
241
                    controller=services_controller,
 
242
                    action="delete_service",
 
243
                    conditions=dict(method=["DELETE"]))
 
244
        mapper.connect("/services/{service_id}",
 
245
                    controller=services_controller,
 
246
                    action="get_service",
 
247
                    conditions=dict(method=["GET"]))
 
248
        super(AdminApi, self).__init__(mapper)