← Back to branch summary

~devcamcar/horizon/trunk

« back to all changes in this revision

Viewing changes to django-openstack/src/django_openstack/nova/views/admin.py

  • Committer: Devin Carlen
  • Date: 2011-06-18 05:59:37 UTC
  • Revision ID: devin.carlen@gmail.com-20110618055937-aobwm0buvviijz3o
Moved codebase to GitHub

Show diffs side-by-side

added added

removed removed

Lines of Context:
django-openstack/src/django_openstack/nova/views/admin.py
1
 
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
 
 
3
 
# Copyright 2010 United States Government as represented by the
4
 
# Administrator of the National Aeronautics and Space Administration.
5
 
# All Rights Reserved.
6
 
#
7
 
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
8
 
#    not use this file except in compliance with the License. You may obtain
9
 
#    a copy of the License at
10
 
#
11
 
#         http://www.apache.org/licenses/LICENSE-2.0
12
 
#
13
 
#    Unless required by applicable law or agreed to in writing, software
14
 
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15
 
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
16
 
#    License for the specific language governing permissions and limitations
17
 
#    under the License.
18
 
 
19
 
"""
20
 
Views for managing Nova through the Django admin interface.
21
 
"""
22
 
 
23
 
import boto.exception
24
 
 
25
 
from django import http
26
 
from django import template
27
 
from django.contrib import messages
28
 
from django.contrib.admin.views.decorators import staff_member_required
29
 
from django.contrib.auth import models as auth_models
30
 
from django.shortcuts import redirect, render_to_response
31
 
from django.utils.translation import ugettext as _
32
 
from django_openstack import log as logging
33
 
from django_openstack import models
34
 
from django_openstack.core.connection import get_nova_admin_connection
35
 
from django_openstack.nova import forms
36
 
 
37
 
 
38
 
LOG = logging.getLogger('django_openstack.nova')
39
 
 
40
 
 
41
 
@staff_member_required
42
 
def project_sendcredentials(request, project_id):
43
 
    nova = get_nova_admin_connection()
44
 
    project = nova.get_project(project_id)
45
 
 
46
 
    users = [user.memberId for user in nova.get_project_members(project_id)]
47
 
    form = forms.SendCredentialsForm(query_list=users)
48
 
 
49
 
    if project == None:
50
 
        LOG.error("Project id %s not found" % project_id)
51
 
        raise http.Http404()
52
 
 
53
 
    if request.method == 'POST':
54
 
        if len(request.POST.getlist('users')) < 1:
55
 
            msg = "Please select a user to send credentials to."
56
 
 
57
 
            return render_to_response(
58
 
                'admin/django_openstack/nova/project/send_credentials.html',
59
 
                {'project': project,
60
 
                 'form': form,
61
 
                 'users': users,
62
 
                 'error': msg},
63
 
                context_instance=template.RequestContext(request))
64
 
        else:
65
 
            for username in request.POST.getlist('users'):
66
 
                models.CredentialsAuthorization.authorize(username, project_id)
67
 
            msg = "Credentials were successfully sent."
68
 
            return render_to_response(
69
 
                'admin/django_openstack/nova/project/send_credentials.html',
70
 
                {'project': project,
71
 
                 'form': form,
72
 
                 'users': users,
73
 
                 'success': msg},
74
 
                context_instance=template.RequestContext(request))
75
 
 
76
 
    return render_to_response(
77
 
        'admin/django_openstack/nova/project/send_credentials.html',
78
 
        {'project': project,
79
 
         'form': form,
80
 
         'users': users},
81
 
        context_instance=template.RequestContext(request))
82
 
 
83
 
 
84
 
@staff_member_required
85
 
def project_start_vpn(request, project_id):
86
 
    nova = get_nova_admin_connection()
87
 
    project = nova.get_project(project_id)
88
 
 
89
 
    if project == None:
90
 
        LOG.error("Project id %s does not exist" % project_id)
91
 
        raise http.Http404()
92
 
 
93
 
    try:
94
 
        nova.start_vpn(project_id)
95
 
        messages.success(request,
96
 
                       _('Successfully started VPN for project %(proj)s.') %
97
 
                         {'proj': project_id})
98
 
        LOG.info('Successfully started VPN for project %s.' % project_id)
99
 
    except boto.exception.EC2ResponseError, e:
100
 
        msg = _('Unable to start VPN for the project %(proj)s: %(code)s - %(msg)s' %
101
 
               {'proj': project_id,
102
 
               'code': e.code,
103
 
               'msg': e.error_message})
104
 
        messages.error(request, msg)
105
 
        LOG.error(msg)
106
 
 
107
 
    return redirect('admin_projects')
108
 
 
109
 
 
110
 
@staff_member_required
111
 
def projects_list(request):
112
 
    nova = get_nova_admin_connection()
113
 
    projects = nova.get_projects()
114
 
 
115
 
    return render_to_response(
116
 
        'admin/django_openstack/nova/project/project_list.html',
117
 
        {'projects': projects},
118
 
        context_instance=template.RequestContext(request))
119
 
 
120
 
 
121
 
@staff_member_required
122
 
def project_view(request, project_name):
123
 
    nova = get_nova_admin_connection()
124
 
    project = nova.get_project(project_name)
125
 
    users = nova.get_project_members(project_name)
126
 
 
127
 
    try:
128
 
        manager = auth_models.User.objects.get(
129
 
                username=project.projectManagerId)
130
 
    except auth_models.User.DoesNotExist:
131
 
        manager = None
132
 
 
133
 
    if request.method == 'POST':
134
 
        form = forms.ProjectForm(request.POST)
135
 
        if form.is_valid():
136
 
            try:
137
 
                nova.modify_project(form.cleaned_data["projectname"],
138
 
                                    form.cleaned_data["manager"],
139
 
                                    form.cleaned_data["description"])
140
 
                msg = _('Successfully modified the project %(proj)s.' %
141
 
                        {'proj': project_name})
142
 
                messages.success(request, msg)
143
 
                LOG.info(msg)
144
 
            except boto.exception.EC2ResponseError, e:
145
 
                msg = _('Unable modify the project %(proj)s: %(code)s - %(msg)s' %
146
 
                        {'proj': project_name,
147
 
                        'code': e.code,
148
 
                        'msg': e.error_message})
149
 
                messages.error(request, msg)
150
 
                LOG.error(msg)
151
 
 
152
 
            return redirect('admin_project', request.POST["projectname"])
153
 
    else:
154
 
        form = forms.ProjectForm(initial={'projectname': project.projectname,
155
 
                                          'description': project.description,
156
 
                                          'manager': manager
157
 
                                         })
158
 
 
159
 
    for user in users:
160
 
        project_role = [str(role.role) for role in
161
 
                nova.get_user_roles(user.memberId, project_name)]
162
 
        global_role = [str(role.role) for role in
163
 
                nova.get_user_roles(user.memberId, project=False)]
164
 
 
165
 
        user.project_roles = ", ".join(project_role)
166
 
        user.global_roles = ", ".join(global_role)
167
 
 
168
 
    return render_to_response(
169
 
        'admin/django_openstack/nova/project/edit_project.html',
170
 
        {'project': project,
171
 
         'users': users,
172
 
         'form': form},
173
 
        context_instance=template.RequestContext(request))
174
 
 
175
 
 
176
 
@staff_member_required
177
 
def add_project(request):
178
 
    nova = get_nova_admin_connection()
179
 
 
180
 
    if request.method == 'POST':
181
 
        form = forms.ProjectForm(request.POST)
182
 
        if form.is_valid():
183
 
            manager = form.cleaned_data['manager']
184
 
            nova.create_project(form.cleaned_data['projectname'],
185
 
                                manager.username,
186
 
                                form.cleaned_data['description'])
187
 
            LOG.info('Project "%s" created' %
188
 
                        form.cleaned_data['projectname'])
189
 
            return redirect('admin_project', request.POST['projectname'])
190
 
    else:
191
 
        form = forms.ProjectForm()
192
 
 
193
 
    return render_to_response(
194
 
        'admin/django_openstack/nova/project/add_project.html',
195
 
        {'form': form},
196
 
        context_instance=template.RequestContext(request))
197
 
 
198
 
 
199
 
@staff_member_required
200
 
def delete_project(request, project_name):
201
 
    nova = get_nova_admin_connection()
202
 
 
203
 
    if request.method == 'POST':
204
 
        nova.delete_project(project_name)
205
 
        LOG.info('Project "%s" deleted' % project_name)
206
 
        return redirect('admin_projects')
207
 
 
208
 
    project = nova.get_project(project_name)
209
 
 
210
 
    return render_to_response(
211
 
        'admin/django_openstack/nova/project/delete_project.html',
212
 
        {'project': project},
213
 
        context_instance=template.RequestContext(request))
214
 
 
215
 
 
216
 
def remove_project_roles(username, project):
217
 
    nova = get_nova_admin_connection()
218
 
    userroles = nova.get_user_roles(username,  project)
219
 
    roles = [str(role.role) for role in userroles]
220
 
 
221
 
    for role in roles:
222
 
        if role == "developer":
223
 
            nova.remove_user_role(username, "developer", project)
224
 
        if role == "sysadmin":
225
 
            nova.remove_user_role(username, "sysadmin", project)
226
 
        if role == "netadmin":
227
 
            nova.remove_user_role(username, "netadmin", project)
228
 
 
229
 
    LOG.info('Removed roles "%s" from user "%s" on project "%s"' %
230
 
                (",".join(roles), username, project))
231
 
 
232
 
 
233
 
def remove_global_roles(username):
234
 
    nova = get_nova_admin_connection()
235
 
    userroles = nova.get_user_roles(username)
236
 
    roles = [str(role.role) for role in userroles]
237
 
 
238
 
    for role in roles:
239
 
        if role == "developer":
240
 
            nova.remove_user_role(username, "developer")
241
 
        if role == "sysadmin":
242
 
            nova.remove_user_role(username, "sysadmin")
243
 
        if role == "netadmin":
244
 
            nova.remove_user_role(username, "netadmin")
245
 
        if role == "cloudadmin":
246
 
            nova.remove_user_role(username, "cloudadmin")
247
 
        if role == "itsec":
248
 
            nova.remove_user_role(username, "itsec")
249
 
 
250
 
    LOG.info('Removed global roles "%s" from user "%s"' %
251
 
             (",".join(roles), username))
252
 
 
253
 
 
254
 
@staff_member_required
255
 
def project_user(request, project_name, project_user):
256
 
    nova = get_nova_admin_connection()
257
 
    project = nova.get_project(project_name)
258
 
    userroles = nova.get_user_roles(project_user, project_name)
259
 
 
260
 
    try:
261
 
        modeluser = auth_models.User.objects.get(username=project_user)
262
 
    except auth_models.User.DoesNotExist:
263
 
        modeluser = None
264
 
 
265
 
    if request.method == 'POST':
266
 
        form = forms.ProjectUserForm(project, request.user, request.POST)
267
 
        if form.is_valid():
268
 
            username = project_user
269
 
 
270
 
            # hacky work around to interface correctly with
271
 
            # multiple select form
272
 
            remove_project_roles(username, project_name)
273
 
 
274
 
            roleform = request.POST.getlist("role")
275
 
            for role in roleform:
276
 
                nova.add_user_role(username, str(role), project_name)
277
 
 
278
 
            LOG.info('Added roles "%s" to user "%s" on project "%s"' %
279
 
                        ",".join(str(role) for role in roleform),
280
 
                        username, project_name)
281
 
 
282
 
            return redirect('admin_project', project_name)
283
 
    else:
284
 
        roles = [str(role.role) for role in userroles]
285
 
        form = forms.ProjectUserForm(project,
286
 
                                     request.user,
287
 
                                     {'role': roles,
288
 
                                      'user': modeluser})
289
 
 
290
 
    return render_to_response(
291
 
        'admin/django_openstack/nova/project/project_user.html',
292
 
        {'form': form,
293
 
         'project': project,
294
 
         'user': modeluser},
295
 
        context_instance=template.RequestContext(request))
296
 
 
297
 
 
298
 
@staff_member_required
299
 
def add_project_user(request, project_name):
300
 
    nova = get_nova_admin_connection()
301
 
 
302
 
    if request.method == 'POST':
303
 
        form = forms.AddProjectUserForm(request.POST, project=project_name)
304
 
        if form.is_valid():
305
 
            username = form.cleaned_data["username"].username
306
 
            roleform = request.POST.getlist("role")
307
 
 
308
 
            nova.add_project_member(username, project_name,)
309
 
 
310
 
            for role in roleform:
311
 
                nova.add_user_role(username, str(role), project_name)
312
 
 
313
 
            LOG.info('Added user "%s" to project "%s" with roles "%s"' %
314
 
                        (username, project_name,
315
 
                        ",".join(str(role) for role in roleform)))
316
 
 
317
 
            return redirect('admin_project', project_name)
318
 
    else:
319
 
        form = forms.AddProjectUserForm(project=project_name)
320
 
 
321
 
    project = nova.get_project(project_name)
322
 
 
323
 
    return render_to_response(
324
 
        'admin/django_openstack/nova/project/add_project_user.html',
325
 
        {'form': form,
326
 
         'project': project},
327
 
        context_instance=template.RequestContext(request))
328
 
 
329
 
 
330
 
@staff_member_required
331
 
def delete_project_user(request, project_name, project_user):
332
 
    nova = get_nova_admin_connection()
333
 
 
334
 
    if request.method == 'POST':
335
 
        nova.remove_project_member(project_user, project_name)
336
 
        return redirect('admin_project', project_name)
337
 
 
338
 
    project = nova.get_project(project_name)
339
 
    user = nova.get_user(project_user)
340
 
 
341
 
    return render_to_response(
342
 
        'admin/django_openstack/nova/project/delete_project_user.html',
343
 
        {'user': user,
344
 
         'project': project},
345
 
        context_instance=template.RequestContext(request))
346
 
 
347
 
 
348
 
@staff_member_required
349
 
def users_list(request):
350
 
    nova = get_nova_admin_connection()
351
 
    users = nova.get_users()
352
 
 
353
 
    for user in users:
354
 
        # NOTE(devcamcar): Temporarily disabled for performance reasons.
355
 
        #roles = [str(role.role) for role in
356
 
        #         nova.get_user_roles(user.username)]
357
 
        roles = []
358
 
        user.roles = ", ".join(roles)
359
 
 
360
 
    return render_to_response(
361
 
        'admin/django_openstack/nova/project/user_list.html',
362
 
        {'users': users},
363
 
        context_instance=template.RequestContext(request))
364
 
 
365
 
 
366
 
@staff_member_required
367
 
def user_roles(request, user_id):
368
 
    nova = get_nova_admin_connection()
369
 
    userroles = nova.get_user_roles(user_id)
370
 
    try:
371
 
        modeluser = auth_models.User.objects.get(username=user_id)
372
 
    except auth_models.User.DoesNotExist:
373
 
        modeluser = None
374
 
 
375
 
    if request.method == 'POST':
376
 
        form = forms.GlobalRolesForm(request.POST)
377
 
        if form.is_valid():
378
 
            username = user_id
379
 
 
380
 
            # hacky work around to interface correctly with
381
 
            # multiple select form
382
 
            remove_global_roles(username)
383
 
 
384
 
            roleform = request.POST.getlist("role")
385
 
            for role in roleform:
386
 
                nova.add_user_role(username, str(role))
387
 
 
388
 
            LOG.info('Added user "%s" to global roles "%s"' %
389
 
                     (username, ",".join(str(role) for role in roleform)))
390
 
 
391
 
            return redirect('admin_user_roles', user_id)
392
 
    else:
393
 
        roles = [str(role.role) for role in userroles]
394
 
        form = forms.GlobalRolesForm({
395
 
            'username': modeluser and modeluser.id or None,
396
 
            'role': roles,
397
 
        })
398
 
 
399
 
    return render_to_response(
400
 
        'admin/django_openstack/nova/project/global_edit_user.html',
401
 
        {'form': form,
402
 
         'user': modeluser},
403
 
        context_instance=template.RequestContext(request))