views.py 90 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
# Copyright 2014 Budapest University of Technology and Economics (BME IK)
#
# This file is part of CIRCLE Cloud.
#
# CIRCLE is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
#
# CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along
# with CIRCLE.  If not, see <http://www.gnu.org/licenses/>.

18
from __future__ import unicode_literals, absolute_import
19

20 21
from os import getenv
import json
Őry Máté committed
22
import logging
23
import re
24
import requests
25

26
from django.conf import settings
27
from django.contrib.auth.models import User, Group
Őry Máté committed
28
from django.contrib.auth.views import login, redirect_to_login
29
from django.contrib.messages import warning
30
from django.core.exceptions import (
31
    PermissionDenied, SuspiciousOperation,
32
)
33 34
from django.core import signing
from django.core.urlresolvers import reverse, reverse_lazy
35
from django.db.models import Count
36
from django.http import HttpResponse, HttpResponseRedirect, Http404
Őry Máté committed
37
from django.shortcuts import redirect, render, get_object_or_404
38
from django.views.decorators.http import require_GET
39
from django.views.generic.detail import SingleObjectMixin
40
from django.views.generic import (TemplateView, DetailView, View, DeleteView,
41
                                  UpdateView, CreateView, ListView)
42 43
from django.contrib import messages
from django.utils.translation import ugettext as _
44
from django.template.defaultfilters import title as title_filter
45
from django.template.loader import render_to_string
46
from django.template import RequestContext
47

48
from django.forms.models import inlineformset_factory
49
from django_tables2 import SingleTableView
50 51
from braces.views import LoginRequiredMixin, SuperuserRequiredMixin
from braces.views._access import AccessMixin
Kálmán Viktor committed
52

53
from .forms import (
54
    CircleAuthenticationForm, DiskAddForm, HostForm, LeaseForm, MyProfileForm,
55
    NodeForm, TemplateForm, TraitForm, VmCustomizeForm, TemplateCloneForm,
56
    CirclePasswordChangeForm
57
)
58
from .tables import (NodeListTable, NodeVmListTable,
59
                     TemplateListTable, LeaseListTable, GroupListTable,)
Őry Máté committed
60 61 62 63
from vm.models import (
    Instance, instance_activity, InstanceActivity, InstanceTemplate, Interface,
    InterfaceTemplate, Lease, Node, NodeActivity, Trait,
)
64
from storage.models import Disk
65
from firewall.models import Vlan, Host, Rule
66
from .models import Favourite, Profile
67

Őry Máté committed
68
logger = logging.getLogger(__name__)
69

70

71 72 73 74
def search_user(keyword):
    try:
        return User.objects.get(username=keyword)
    except User.DoesNotExist:
75 76 77 78
        try:
            return User.objects.get(profile__org_id=keyword)
        except User.DoesNotExist:
            return User.objects.get(email=keyword)
79 80


81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
# github.com/django/django/blob/stable/1.6.x/django/contrib/messages/views.py
class SuccessMessageMixin(object):
    """
    Adds a success message on successful form submission.
    """
    success_message = ''

    def form_valid(self, form):
        response = super(SuccessMessageMixin, self).form_valid(form)
        success_message = self.get_success_message(form.cleaned_data)
        if success_message:
            messages.success(self.request, success_message)
        return response

    def get_success_message(self, cleaned_data):
        return self.success_message % cleaned_data


99
class IndexView(LoginRequiredMixin, TemplateView):
Kálmán Viktor committed
100
    template_name = "dashboard/index.html"
101

102
    def get_context_data(self, **kwargs):
103
        user = self.request.user
104
        context = super(IndexView, self).get_context_data(**kwargs)
105

106
        # instances
107
        favs = Instance.objects.filter(favourite__user=self.request.user)
108
        instances = Instance.get_objects_with_level(
109
            'user', user, disregard_superuser=True).filter(destroyed_at=None)
110 111 112
        display = list(favs) + list(set(instances) - set(favs))
        for d in display:
            d.fav = True if d in favs else False
113
        context.update({
114
            'instances': display[:5],
115
            'more_instances': instances.count() - len(instances[:5])
116 117
        })

118 119
        running = instances.filter(status='RUNNING')
        stopped = instances.exclude(status__in=('RUNNING', 'NOSTATE'))
120

121
        context.update({
122 123 124
            'running_vms': running[:20],
            'running_vm_num': running.count(),
            'stopped_vm_num': stopped.count()
125
        })
126

127 128 129 130
        # nodes
        if user.is_superuser:
            nodes = Node.objects.all()
            context.update({
131 132
                'nodes': nodes[:5],
                'more_nodes': nodes.count() - len(nodes[:5]),
133 134 135 136 137 138 139 140 141 142 143 144
                'sum_node_num': nodes.count(),
                'node_num': {
                    'running': Node.get_state_count(True, True),
                    'missing': Node.get_state_count(False, True),
                    'disabled': Node.get_state_count(True, False),
                    'offline': Node.get_state_count(False, False)
                }
            })

        # groups
        groups = Group.objects.all()
        context.update({
145 146
            'groups': groups[:5],
            'more_groups': groups.count() - len(groups[:5]),
147 148 149 150 151 152 153
        })

        # template
        if user.has_perm('vm.create_template'):
            context['templates'] = InstanceTemplate.get_objects_with_level(
                'operator', user).all()[:5]

154 155
        return context

156

157
def get_vm_acl_data(obj):
158 159 160 161 162 163 164 165 166
    levels = obj.ACL_LEVELS
    users = obj.get_users_with_level()
    users = [{'user': u, 'level': l} for u, l in users]
    groups = obj.get_groups_with_level()
    groups = [{'group': g, 'level': l} for g, l in groups]
    return {'users': users, 'groups': groups, 'levels': levels,
            'url': reverse('dashboard.views.vm-acl', args=[obj.pk])}


167 168 169 170 171 172 173 174 175 176 177
def get_group_acl_data(obj):
    aclobj = obj.profile
    levels = aclobj.ACL_LEVELS
    users = aclobj.get_users_with_level()
    users = [{'user': u, 'level': l} for u, l in users]
    groups = aclobj.get_groups_with_level()
    groups = [{'group': g, 'level': l} for g, l in groups]
    return {'users': users, 'groups': groups, 'levels': levels,
            'url': reverse('dashboard.views.group-acl', args=[obj.pk])}


178
class CheckedDetailView(LoginRequiredMixin, DetailView):
179 180
    read_level = 'user'

181 182 183
    def get_has_level(self):
        return self.object.has_level

184 185
    def get_context_data(self, **kwargs):
        context = super(CheckedDetailView, self).get_context_data(**kwargs)
186
        if not self.get_has_level()(self.request.user, self.read_level):
187 188 189 190
            raise PermissionDenied()
        return context


191 192 193 194 195 196 197 198 199
class VmDetailVncTokenView(CheckedDetailView):
    template_name = "dashboard/vm-detail.html"
    model = Instance

    def get(self, request, **kwargs):
        self.object = self.get_object()
        if not self.object.has_level(request.user, 'operator'):
            raise PermissionDenied()
        if self.object.node:
200 201 202 203 204 205 206 207
            with instance_activity(code_suffix='console-accessed',
                                   instance=self.object, user=request.user,
                                   concurrency_check=False):
                port = self.object.vnc_port
                host = str(self.object.node.host.ipv4)
                value = signing.dumps({'host': host, 'port': port},
                                      key=getenv("PROXY_SECRET", 'asdasd')),
                return HttpResponse('vnc/?d=%s' % value)
208 209 210 211
        else:
            raise Http404()


212
class VmDetailView(CheckedDetailView):
Kálmán Viktor committed
213
    template_name = "dashboard/vm-detail.html"
214
    model = Instance
215 216

    def get_context_data(self, **kwargs):
217
        context = super(VmDetailView, self).get_context_data(**kwargs)
218
        instance = context['instance']
219 220 221
        context.update({
            'graphite_enabled': VmGraphView.get_graphite_url() is not None,
            'vnc_url': reverse_lazy("dashboard.views.detail-vnc",
222
                                    kwargs={'pk': self.object.pk}),
223
            'ops': get_operations(instance, self.request.user),
224
        })
225 226

        # activity data
227 228 229 230 231
        context['activities'] = (
            InstanceActivity.objects.filter(
                instance=self.object, parent=None).
            order_by('-started').
            select_related('user').prefetch_related('children'))
232

233
        context['vlans'] = Vlan.get_objects_with_level(
234
            'user', self.request.user
235
        ).exclude(  # exclude already added interfaces
236 237 238
            pk__in=Interface.objects.filter(
                instance=self.get_object()).values_list("vlan", flat=True)
        ).all()
239
        context['acl'] = get_vm_acl_data(instance)
240
        context['forms'] = {
241
            'disk_add_form': DiskAddForm(
242
                user=self.request.user,
243
                is_template=False, object_pk=self.get_object().pk,
244
                prefix="disk"),
245
        }
246 247
        context['os_type_icon'] = instance.os_type.replace("unknown",
                                                           "question")
248
        return context
Kálmán Viktor committed
249

250 251 252 253 254
    def post(self, request, *args, **kwargs):
        if (request.POST.get('ram-size') and request.POST.get('cpu-count')
                and request.POST.get('cpu-priority')):
            return self.__set_resources(request)

255 256 257
        options = {
            'change_password': self.__change_password,
            'new_name': self.__set_name,
258
            'new_description': self.__set_description,
259 260
            'new_tag': self.__add_tag,
            'to_remove': self.__remove_tag,
261 262
            'port': self.__add_port,
            'new_network_vlan': self.__new_network,
263 264 265 266
        }
        for k, v in options.iteritems():
            if request.POST.get(k) is not None:
                return v(request)
Kálmán Viktor committed
267

268 269 270 271
    def __change_password(self, request):
        self.object = self.get_object()
        if not self.object.has_level(request.user, 'owner'):
            raise PermissionDenied()
Kálmán Viktor committed
272

273 274 275 276 277 278 279
        self.object.change_password(user=request.user)
        messages.success(request, _("Password changed!"))
        if request.is_ajax():
            return HttpResponse("Success!")
        else:
            return redirect(reverse_lazy("dashboard.views.detail",
                                         kwargs={'pk': self.object.pk}))
280

281 282 283 284
    def __set_resources(self, request):
        self.object = self.get_object()
        if not self.object.has_level(request.user, 'owner'):
            raise PermissionDenied()
285 286
        if not request.user.has_perm('vm.change_resources'):
            raise PermissionDenied()
287 288 289 290

        resources = {
            'num_cores': request.POST.get('cpu-count'),
            'ram_size': request.POST.get('ram-size'),
291
            'max_ram_size': request.POST.get('ram-size'),  # TODO: max_ram
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
            'priority': request.POST.get('cpu-priority')
        }
        Instance.objects.filter(pk=self.object.pk).update(**resources)

        success_message = _("Resources successfully updated!")
        if request.is_ajax():
            response = {'message': success_message}
            return HttpResponse(
                json.dumps(response),
                content_type="application/json"
            )
        else:
            messages.success(request, success_message)
            return redirect(reverse_lazy("dashboard.views.detail",
                                         kwargs={'pk': self.object.pk}))

308 309
    def __set_name(self, request):
        self.object = self.get_object()
310 311
        if not self.object.has_level(request.user, 'owner'):
            raise PermissionDenied()
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
        new_name = request.POST.get("new_name")
        Instance.objects.filter(pk=self.object.pk).update(
            **{'name': new_name})

        success_message = _("VM successfully renamed!")
        if request.is_ajax():
            response = {
                'message': success_message,
                'new_name': new_name,
                'vm_pk': self.object.pk
            }
            return HttpResponse(
                json.dumps(response),
                content_type="application/json"
            )
        else:
            messages.success(request, success_message)
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
            return redirect(self.object.get_absolute_url())

    def __set_description(self, request):
        self.object = self.get_object()
        if not self.object.has_level(request.user, 'owner'):
            raise PermissionDenied()

        new_description = request.POST.get("new_description")
        Instance.objects.filter(pk=self.object.pk).update(
            **{'description': new_description})

        success_message = _("VM description successfully updated!")
        if request.is_ajax():
            response = {
                'message': success_message,
                'new_description': new_description,
            }
            return HttpResponse(
                json.dumps(response),
                content_type="application/json"
            )
        else:
            messages.success(request, success_message)
            return redirect(self.object.get_absolute_url())
353

Kálmán Viktor committed
354 355 356
    def __add_tag(self, request):
        new_tag = request.POST.get('new_tag')
        self.object = self.get_object()
357 358
        if not self.object.has_level(request.user, 'owner'):
            raise PermissionDenied()
Kálmán Viktor committed
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378

        if len(new_tag) < 1:
            message = u"Please input something!"
        elif len(new_tag) > 20:
            message = u"Tag name is too long!"
        else:
            self.object.tags.add(new_tag)

        try:
            messages.error(request, message)
        except:
            pass

        return redirect(reverse_lazy("dashboard.views.detail",
                                     kwargs={'pk': self.object.pk}))

    def __remove_tag(self, request):
        try:
            to_remove = request.POST.get('to_remove')
            self.object = self.get_object()
379 380
            if not self.object.has_level(request.user, 'owner'):
                raise PermissionDenied()
Kálmán Viktor committed
381 382 383 384 385 386 387 388 389 390 391

            self.object.tags.remove(to_remove)
            message = u"Success"
        except:  # note this won't really happen
            message = u"Not success"

        if request.is_ajax():
            return HttpResponse(
                json.dumps({'message': message}),
                content_type="application=json"
            )
392 393 394
        else:
            return redirect(reverse_lazy("dashboard.views.detail",
                            kwargs={'pk': self.object.pk}))
Kálmán Viktor committed
395

396 397
    def __add_port(self, request):
        object = self.get_object()
398 399
        if (not object.has_level(request.user, 'owner') or
                not request.user.has_perm('vm.config_ports')):
400
            raise PermissionDenied()
401 402 403 404 405 406

        port = request.POST.get("port")
        proto = request.POST.get("proto")

        try:
            error = None
407 408 409
            interfaces = object.interface_set.all()
            host = Host.objects.get(pk=request.POST.get("host_pk"),
                                    interface__in=interfaces)
410
            host.add_port(proto, private=port)
411 412 413 414 415
        except Host.DoesNotExist:
            logger.error('Tried to add port to nonexistent host %d. User: %s. '
                         'Instance: %s', request.POST.get("host_pk"),
                         unicode(request.user), object)
            raise PermissionDenied()
416 417
        except ValueError:
            error = _("There is a problem with your input!")
418
        except Exception as e:
Bach Dániel committed
419 420
            error = _("Unknown error.")
            logger.error(e)
421 422 423 424 425 426 427 428 429

        if request.is_ajax():
            pass
        else:
            if error:
                messages.error(request, error)
            return redirect(reverse_lazy("dashboard.views.detail",
                                         kwargs={'pk': self.get_object().pk}))

430 431 432 433 434
    def __new_network(self, request):
        self.object = self.get_object()
        if not self.object.has_level(request.user, 'owner'):
            raise PermissionDenied()

435
        vlan = get_object_or_404(Vlan, pk=request.POST.get("new_network_vlan"))
436 437
        if not vlan.has_level(request.user, 'user'):
            raise PermissionDenied()
438
        try:
439
            self.object.add_interface(vlan=vlan, user=request.user)
440 441 442 443 444 445 446 447
            messages.success(request, _("Successfully added new interface!"))
        except Exception, e:
            error = u' '.join(e.messages)
            messages.error(request, error)

        return redirect("%s#network" % reverse_lazy(
            "dashboard.views.detail", kwargs={'pk': self.object.pk}))

448

449
class OperationView(DetailView):
450

451
    template_name = 'dashboard/operate.html'
452

453 454 455
    @property
    def name(self):
        return self.get_op().name
456

457 458 459
    @property
    def description(self):
        return self.get_op().description
460

461 462 463
    @classmethod
    def get_urlname(cls):
        return 'dashboard.vm.op.%s' % cls.op
464

465 466
    def get_url(self):
        return reverse(self.get_urlname(), args=(self.get_object().pk, ))
467

468 469 470 471 472
    def get_wrapper_template_name(self):
        if self.request.is_ajax():
            return 'dashboard/_modal.html'
        else:
            return 'dashboard/_base.html'
473

474 475 476
    @classmethod
    def get_op_by_object(cls, obj):
        return getattr(obj, cls.op)
477

478 479 480 481
    def get_op(self):
        if not hasattr(self, '_opobj'):
            setattr(self, '_opobj', getattr(self.get_object(), self.op))
        return self._opobj
482

483
    def get_context_data(self, **kwargs):
484
        ctx = super(OperationView, self).get_context_data(**kwargs)
485 486 487
        ctx['op'] = self.get_op()
        ctx['url'] = self.request.path
        return ctx
488

489 490 491 492 493 494 495
    def get(self, request, *args, **kwargs):
        self.get_op().check_auth(request.user)
        response = super(OperationView, self).get(request, *args, **kwargs)
        response.render()
        response.content = render_to_string(self.get_wrapper_template_name(),
                                            {'body': response.content})
        return response
496

497
    def post(self, request, extra=None, *args, **kwargs):
498
        self.object = self.get_object()
499 500
        if extra is None:
            extra = {}
501
        try:
502
            self.get_op().async(user=request.user, **extra)
503 504 505
        except Exception as e:
            messages.error(request, _('Could not start operation.'))
            logger.error(e)
506
        return redirect("%s#activity" % self.object.get_absolute_url())
507

508 509 510 511
    @classmethod
    def factory(cls, op, icon='cog'):
        return type(str(cls.__name__ + op),
                    (cls, ), {'op': op, 'icon': icon})
512

513 514 515 516 517 518 519 520 521 522
    @classmethod
    def bind_to_object(cls, instance):
        v = cls()
        v.get_object = lambda: instance
        return v


class VmOperationView(OperationView):

    model = Instance
523
    context_object_name = 'instance'  # much simpler to mock object
524

525

526 527 528 529 530 531 532
class VmMigrateView(VmOperationView):

    op = 'migrate'
    icon = 'truck'
    template_name = 'dashboard/_vm-migrate.html'

    def get_context_data(self, **kwargs):
533
        ctx = super(VmMigrateView, self).get_context_data(**kwargs)
534 535 536 537 538
        ctx['nodes'] = [n for n in Node.objects.filter(enabled=True)
                        if n.state == "ONLINE"]
        return ctx

    def post(self, request, extra=None, *args, **kwargs):
539 540
        if extra is None:
            extra = {}
541 542 543 544 545 546 547
        node = self.request.POST.get("node")
        if node:
            node = get_object_or_404(Node, pk=node)
            extra["to_node"] = node
        return super(VmMigrateView, self).post(request, extra, *args, **kwargs)


548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
class VmSaveView(VmOperationView):

    op = 'save_as_template'
    icon = 'save'
    template_name = 'dashboard/_vm-save.html'

    def get_context_data(self, **kwargs):
        ctx = super(VmSaveView, self).get_context_data(**kwargs)
        ctx['name'] = self.get_op()._rename(self.object.name)
        return ctx

    def post(self, request, extra=None, *args, **kwargs):
        if extra is None:
            extra = {}
        name = self.request.POST.get("name")
        if name:
            extra["name"] = name
        return super(VmSaveView, self).post(request, extra, *args, **kwargs)


568 569 570
vm_ops = {
    'reset': VmOperationView.factory(op='reset', icon='bolt'),
    'deploy': VmOperationView.factory(op='deploy', icon='play'),
571
    'migrate': VmMigrateView,
572 573 574
    'reboot': VmOperationView.factory(op='reboot', icon='refresh'),
    'shut_off': VmOperationView.factory(op='shut_off', icon='ban-circle'),
    'shutdown': VmOperationView.factory(op='shutdown', icon='off'),
575
    'save_as_template': VmSaveView,
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
    'destroy': VmOperationView.factory(op='destroy', icon='remove'),
    'sleep': VmOperationView.factory(op='sleep', icon='moon'),
    'wake_up': VmOperationView.factory(op='wake_up', icon='sun'),
}


def get_operations(instance, user):
    ops = []
    for k, v in vm_ops.iteritems():
        try:
            op = v.get_op_by_object(instance)
            op.check_auth(user)
            op.check_precond()
        except:
            pass  # unavailable
        else:
            ops.append(v.bind_to_object(instance))
    return ops
594

Kálmán Viktor committed
595

596
class NodeDetailView(LoginRequiredMixin, SuperuserRequiredMixin, DetailView):
597 598
    template_name = "dashboard/node-detail.html"
    model = Node
599 600
    form = None
    form_class = TraitForm
601

602 603 604
    def get_context_data(self, form=None, **kwargs):
        if form is None:
            form = self.form_class()
605
        context = super(NodeDetailView, self).get_context_data(**kwargs)
606 607
        instances = Instance.active.filter(node=self.object)
        context['table'] = NodeVmListTable(instances)
608 609 610 611
        na = NodeActivity.objects.filter(
            node=self.object, parent=None
        ).order_by('-started').select_related()
        context['activities'] = na
612
        context['trait_form'] = form
613 614
        context['graphite_enabled'] = (
            NodeGraphView.get_graphite_url() is not None)
615 616
        return context

617 618 619
    def post(self, request, *args, **kwargs):
        if request.POST.get('new_name'):
            return self.__set_name(request)
620 621
        if request.POST.get('to_remove'):
            return self.__remove_trait(request)
622 623
        return redirect(reverse_lazy("dashboard.views.node-detail",
                                     kwargs={'pk': self.get_object().pk}))
624 625 626 627 628 629 630 631 632 633 634 635 636

    def __set_name(self, request):
        self.object = self.get_object()
        new_name = request.POST.get("new_name")
        Node.objects.filter(pk=self.object.pk).update(
            **{'name': new_name})

        success_message = _("Node successfully renamed!")
        if request.is_ajax():
            response = {
                'message': success_message,
                'new_name': new_name,
                'node_pk': self.object.pk
637 638 639 640 641 642 643 644 645 646
            }
            return HttpResponse(
                json.dumps(response),
                content_type="application/json"
            )
        else:
            messages.success(request, success_message)
            return redirect(reverse_lazy("dashboard.views.node-detail",
                                         kwargs={'pk': self.object.pk}))

647 648 649 650
    def __remove_trait(self, request):
        try:
            to_remove = request.POST.get('to_remove')
            self.object = self.get_object()
651
            self.object.traits.remove(to_remove)
652 653 654 655 656 657 658
            message = u"Success"
        except:  # note this won't really happen
            message = u"Not success"

        if request.is_ajax():
            return HttpResponse(
                json.dumps({'message': message}),
659
                content_type="application/json"
660
            )
661
        else:
662
            return redirect(self.object.get_absolute_url())
663

664

665
class GroupDetailView(CheckedDetailView):
666 667
    template_name = "dashboard/group-detail.html"
    model = Group
668 669 670

    def get_has_level(self):
        return self.object.profile.has_level
671 672 673

    def get_context_data(self, **kwargs):
        context = super(GroupDetailView, self).get_context_data(**kwargs)
674 675 676
        context['group'] = self.object
        context['users'] = self.object.user_set.all()
        context['acl'] = get_group_acl_data(self.object)
677 678 679
        return context

    def post(self, request, *args, **kwargs):
680

681 682 683 684 685 686 687 688 689
        if request.POST.get('new_name'):
            return self.__set_name(request)

    def __set_name(self, request):
        self.object = self.get_object()
        new_name = request.POST.get("new_name")
        Group.objects.filter(pk=self.object.pk).update(
            **{'name': new_name})

690
        success_message = _("Group successfully renamed!")
691 692 693 694
        if request.is_ajax():
            response = {
                'message': success_message,
                'new_name': new_name,
695
                'group_pk': self.object.pk
696 697 698 699 700 701 702 703 704 705 706
            }
            return HttpResponse(
                json.dumps(response),
                content_type="application/json"
            )
        else:
            messages.success(request, success_message)
            return redirect(reverse_lazy("dashboard.views.group-detail",
                                         kwargs={'pk': self.object.pk}))


707
class AclUpdateView(LoginRequiredMixin, View, SingleObjectMixin):
708

709
    def post(self, request, *args, **kwargs):
710
        instance = self.get_object()
711 712
        if not (instance.has_level(request.user, "owner") or
                getattr(instance, 'owner', None) == request.user):
Őry Máté committed
713 714
            logger.warning('Tried to set permissions of %s by non-owner %s.',
                           unicode(instance), unicode(request.user))
715
            raise PermissionDenied()
716 717 718 719 720
        self.set_levels(request, instance)
        self.add_levels(request, instance)
        return redirect(instance)

    def set_levels(self, request, instance):
721 722 723
        for key, value in request.POST.items():
            m = re.match('perm-([ug])-(\d+)', key)
            if m:
724 725
                typ, id = m.groups()
                entity = {'u': User, 'g': Group}[typ].objects.get(id=id)
726
                if getattr(instance, "owner", None) == entity:
727 728 729
                    logger.info("Tried to set owner's acl level for %s by %s.",
                                unicode(instance), unicode(request.user))
                    continue
730
                instance.set_level(entity, value)
Őry Máté committed
731 732 733
                logger.info("Set %s's acl level for %s to %s by %s.",
                            unicode(entity), unicode(instance),
                            value, unicode(request.user))
734

735
    def add_levels(self, request, instance):
736 737
        name = request.POST['perm-new-name']
        value = request.POST['perm-new']
738 739 740 741 742 743
        if not name:
            return
        try:
            entity = User.objects.get(username=name)
        except User.DoesNotExist:
            entity = None
744 745
            try:
                entity = Group.objects.get(name=name)
746 747 748 749
            except Group.DoesNotExist:
                warning(request, _('User or group "%s" not found.') % name)
                return

750
        instance.set_level(entity, value)
Őry Máté committed
751 752 753
        logger.info("Set %s's new acl level for %s to %s by %s.",
                    unicode(entity), unicode(instance),
                    value, unicode(request.user))
754

Kálmán Viktor committed
755

756 757 758 759 760 761 762 763 764 765
class TemplateAclUpdateView(AclUpdateView):
    model = InstanceTemplate

    def post(self, request, *args, **kwargs):
        template = self.get_object()
        if not (template.has_level(request.user, "owner") or
                getattr(template, 'owner', None) == request.user):
            logger.warning('Tried to set permissions of %s by non-owner %s.',
                           unicode(template), unicode(request.user))
            raise PermissionDenied()
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780

        name = request.POST['perm-new-name']
        if (User.objects.filter(username=name).count() +
                Group.objects.filter(name=name).count() < 1
                and len(name) > 0):
            warning(request, _('User or group "%s" not found.') % name)
        else:
            self.set_levels(request, template)
            self.add_levels(request, template)

            post_for_disk = request.POST.copy()
            post_for_disk['perm-new'] = 'user'
            request.POST = post_for_disk
            for d in template.disks.all():
                self.add_levels(request, d)
781 782 783 784 785

        return redirect(reverse("dashboard.views.template-detail",
                                kwargs=self.kwargs))


786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
class GroupAclUpdateView(AclUpdateView):
    model = Group

    def post(self, request, *args, **kwargs):
        instance = self.get_object().profile
        if not (instance.has_level(request.user, "owner") or
                getattr(instance, 'owner', None) == request.user):
            logger.warning('Tried to set permissions of %s by non-owner %s.',
                           unicode(instance), unicode(request.user))
            raise PermissionDenied()
        name = request.POST['perm-new-name']
        if (User.objects.filter(username=name).count() +
                Group.objects.filter(name=name).count() < 1
                and len(name) > 0):
            warning(request, _('User or group "%s" not found.') % name)
        else:
            self.set_levels(request, instance)
            self.add_levels(request, instance)
#        return redirect(self.profile)
        return redirect(reverse("dashboard.views.group-detail",
                                kwargs=self.kwargs))

    def repost(self, request, *args, **kwargs):
        group = self.get_object()
        if not (group.profile.has_level(request.user, "owner") or
                getattr(group.profile, 'owner', None) == request.user):
            logger.warning('Tried to set permissions of %s by non-owner %s.',
                           unicode(group), unicode(request.user))
            raise PermissionDenied()

        name = request.POST['perm-new-name']
        if (User.objects.filter(username=name).count() +
                Group.objects.filter(name=name).count() < 1
                and len(name) > 0):
            warning(request, _('User or group "%s" not found.') % name)
        else:
            self.set_levels(request, group.profile)
            self.add_levels(request, group.profile)

        return redirect(reverse("dashboard.views.group-detail",
                                kwargs=self.kwargs))


829 830 831 832 833 834 835 836 837 838
class TemplateChoose(TemplateView):

    def get_template_names(self):
        if self.request.is_ajax():
            return ['dashboard/modal-wrapper.html']
        else:
            return ['dashboard/nojs-wrapper.html']

    def get_context_data(self, *args, **kwargs):
        context = super(TemplateChoose, self).get_context_data(*args, **kwargs)
839
        templates = InstanceTemplate.get_objects_with_level("operator",
840 841 842 843 844
                                                            self.request.user)
        context.update({
            'box_title': _('Choose template'),
            'ajax_title': False,
            'template': "dashboard/_template-create-1.html",
845
            'templates': templates.all(),  # TODO acl?
846 847 848
        })
        return context

849 850 851 852 853 854 855
    def post(self, request, *args, **kwargs):
        if not request.user.has_perm('vm.create_template'):
            raise PermissionDenied()

        template = request.POST.get("parent")
        if template == "base_vm":
            return redirect(reverse("dashboard.views.template-create"))
856 857 858
        elif template is None:
            messages.warning(request, _("Select an option to proceed!"))
            return redirect(reverse("dashboard.views.template-choose"))
859 860 861 862 863 864 865 866
        else:
            template = get_object_or_404(InstanceTemplate, pk=template)

        instance = Instance.create_from_template(
            template=template, owner=request.user, is_base=True)

        return redirect(instance.get_absolute_url())

867

868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
class TemplateClone(CreateView):
    template_name = "dashboard/template-clone.html"
    form_class = TemplateCloneForm
    model = InstanceTemplate

    def get_form_kwargs(self):
        kwargs = super(TemplateClone, self).get_form_kwargs()
        kwargs['clone_from'] = self.kwargs['pk']
        kwargs['user'] = self.request.user
        return kwargs

    def get(self, *args, **kwargs):
        if not self.request.user.has_perm('vm.create_template'):
            raise PermissionDenied()

        return super(TemplateClone, self).get(*args, **kwargs)

    def post(self, request, *args, **kwargs):
        if not self.request.user.has_perm('vm.create_template'):
            raise PermissionDenied()

        form = self.form_class(request.POST, clone_from=kwargs['pk'],
                               user=request.user)
        if not form.is_valid():
            return self.get(request, form, *args, **kwargs)
        else:
            # clone template
            return redirect("/")  # temp


898 899 900 901
class TemplateCreate(SuccessMessageMixin, CreateView):
    model = InstanceTemplate
    form_class = TemplateForm

902 903 904 905 906 907 908 909 910 911
    def get_template_names(self):
        if self.request.is_ajax():
            return ['dashboard/modal-wrapper.html']
        else:
            return ['dashboard/nojs-wrapper.html']

    def get_context_data(self, *args, **kwargs):
        context = super(TemplateCreate, self).get_context_data(*args, **kwargs)

        context.update({
912
            'box_title': _("Create a new base VM"),
913 914
            'ajax_title': False,
            'template': "dashboard/_template-create-2.html",
915
            'leases': Lease.objects.count()
916 917 918
        })
        return context

919
    def get(self, *args, **kwargs):
920 921
        if not self.request.user.has_perm('vm.create_template'):
            raise PermissionDenied()
922

923 924 925 926 927 928
        self.parent = self.request.GET.get("parent")
        return super(TemplateCreate, self).get(*args, **kwargs)

    def get_form_kwargs(self):
        kwargs = super(TemplateCreate, self).get_form_kwargs()
        kwargs['parent'] = getattr(self, "parent", None)
929
        kwargs['user'] = self.request.user
930 931
        return kwargs

932 933 934
    def post(self, request, *args, **kwargs):
        if not self.request.user.has_perm('vm.create_template'):
            raise PermissionDenied()
935 936

        form = self.form_class(request.POST, user=request.user)
937 938
        if not form.is_valid():
            return self.get(request, form, *args, **kwargs)
939
        else:
940 941
            post = form.cleaned_data

942 943
            networks = self.__create_networks(post.pop("networks"),
                                              request.user)
944
            post.pop("parent")
945
            parent_type = post.pop("parent_type")
946
            post['max_ram_size'] = post['ram_size']
947 948 949 950

            # if it's not a base vm we need to add disks and deploy it
            if parent_type != "base_vm":
                template = get_object_or_404(InstanceTemplate, pk=parent_type)
951 952 953
                inst = Instance.create_from_template(template=template,
                                                     networks=networks,
                                                     **post)
954
                inst.deploy_async()
955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
                messages.info(request, _("Your instance has been created, "
                                         "modify it then press the save as "
                                         "button to save it as a new template!"
                                         ))

            else:
                req_traits = post.pop("req_traits")
                tags = post.pop("tags")
                post['pw'] = User.objects.make_random_password()
                inst = Instance.create(params=post, disks=[],
                                       networks=networks,
                                       tags=tags, req_traits=req_traits)
                messages.info(request, _("Your new base vm has been created, "
                                         "add disks, make modifications, then"
                                         " use the save as button to save it"
                                         " as a new template!"
                                         ))
972

973
            return redirect("%s#resources" % inst.get_absolute_url())
974

975 976
        return super(TemplateCreate, self).post(self, request, args, kwargs)

977
    def __create_networks(self, vlans, user):
978 979
        networks = []
        for v in vlans:
980 981
            if not v.has_level(user, "user"):
                raise PermissionDenied()
982 983 984
            networks.append(InterfaceTemplate(vlan=v, managed=v.managed))
        return networks

985 986 987 988
    def get_success_url(self):
        return reverse_lazy("dashboard.views.template-list")


989
class TemplateDetail(LoginRequiredMixin, SuccessMessageMixin, UpdateView):
990
    model = InstanceTemplate
991 992 993
    template_name = "dashboard/template-edit.html"
    form_class = TemplateForm
    success_message = _("Successfully modified template!")
994 995

    def get(self, request, *args, **kwargs):
996
        template = self.get_object()
997
        if not template.has_level(request.user, 'user'):
998
            raise PermissionDenied()
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
        if request.is_ajax():
            template = {
                'num_cores': template.num_cores,
                'ram_size': template.ram_size,
                'priority': template.priority,
                'arch': template.arch,
                'description': template.description,
                'system': template.system,
                'name': template.name,
                'disks': [{'pk': d.pk, 'name': d.name}
                          for d in template.disks.all()],
                'network': [
                    {'vlan_pk': i.vlan.pk, 'vlan': i.vlan.name,
                     'managed': i.managed}
                    for i in InterfaceTemplate.objects.filter(
                        template=self.get_object()).all()
                ]
            }
            return HttpResponse(json.dumps(template),
                                content_type="application/json")
        else:
1020 1021
            return super(TemplateDetail, self).get(request, *args, **kwargs)

1022
    def get_context_data(self, **kwargs):
1023
        obj = self.get_object()
1024
        context = super(TemplateDetail, self).get_context_data(**kwargs)
1025 1026
        context['acl'] = get_vm_acl_data(obj)
        context['disks'] = obj.disks.all()
1027
        context['disk_add_form'] = DiskAddForm(
1028
            user=self.request.user,
1029
            is_template=True,
1030
            object_pk=obj.pk,
1031 1032
            prefix="disk",
        )
1033 1034
        return context

1035 1036 1037 1038
    def get_success_url(self):
        return reverse_lazy("dashboard.views.template-detail",
                            kwargs=self.kwargs)

1039 1040 1041 1042 1043 1044 1045
    def post(self, request, *args, **kwargs):
        template = self.get_object()
        if not template.has_level(request.user, 'owner'):
            raise PermissionDenied()
        for disk in self.get_object().disks.all():
            if not disk.has_level(request.user, 'user'):
                raise PermissionDenied()
1046 1047 1048
        for network in self.get_object().interface_set.all():
            if not network.vlan.has_level(request.user, "user"):
                raise PermissionDenied()
1049 1050
        return super(TemplateDetail, self).post(self, request, args, kwargs)

1051 1052 1053 1054 1055
    def get_form_kwargs(self):
        kwargs = super(TemplateDetail, self).get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs

1056

1057
class TemplateList(LoginRequiredMixin, SingleTableView):
1058 1059 1060 1061 1062 1063 1064
    template_name = "dashboard/template-list.html"
    model = InstanceTemplate
    table_class = TemplateListTable
    table_pagination = False

    def get_context_data(self, *args, **kwargs):
        context = super(TemplateList, self).get_context_data(*args, **kwargs)
1065 1066
        context['lease_table'] = LeaseListTable(Lease.objects.all(),
                                                request=self.request)
1067
        return context
1068

1069 1070 1071 1072 1073 1074
    def get_queryset(self):
        logger.debug('TemplateList.get_queryset() called. User: %s',
                     unicode(self.request.user))
        return InstanceTemplate.get_objects_with_level(
            'user', self.request.user).all()

1075

1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
class TemplateDelete(LoginRequiredMixin, DeleteView):
    model = InstanceTemplate

    def get_success_url(self):
        return reverse("dashboard.views.template-list")

    def get_template_names(self):
        if self.request.is_ajax():
            return ['dashboard/confirm/ajax-delete.html']
        else:
            return ['dashboard/confirm/base-delete.html']

    def delete(self, request, *args, **kwargs):
        object = self.get_object()
        if not object.has_level(request.user, 'owner'):
            raise PermissionDenied()

        object.delete()
        success_url = self.get_success_url()
        success_message = _("Template successfully deleted!")

        if request.is_ajax():
            return HttpResponse(
                json.dumps({'message': success_message}),
                content_type="application/json",
            )
        else:
            messages.success(request, success_message)
            return HttpResponseRedirect(success_url)


1107
class VmList(LoginRequiredMixin, ListView):
Kálmán Viktor committed
1108
    template_name = "dashboard/vm-list.html"
1109

1110 1111
    def get(self, *args, **kwargs):
        if self.request.is_ajax():
1112 1113 1114 1115
            favs = Instance.objects.filter(
                favourite__user=self.request.user).values_list('pk', flat=True)
            instances = Instance.get_objects_with_level(
                'user', self.request.user).filter(
1116
                destroyed_at=None).all()
1117 1118 1119
            instances = [{
                'pk': i.pk,
                'name': i.name,
1120 1121 1122
                'icon': i.get_status_icon(),
                'host': "" if not i.primary_host else i.primary_host.hostname,
                'status': i.get_status_display(),
1123
                'fav': i.pk in favs} for i in instances]
1124
            return HttpResponse(
1125
                json.dumps(list(instances)),  # instances is ValuesQuerySet
1126 1127 1128 1129 1130
                content_type="application/json",
            )
        else:
            return super(VmList, self).get(*args, **kwargs)

1131
    def get_queryset(self):
1132
        logger.debug('VmList.get_queryset() called. User: %s',
1133
                     unicode(self.request.user))
1134
        queryset = Instance.get_objects_with_level(
1135
            'user', self.request.user).filter(destroyed_at=None)
1136 1137 1138
        s = self.request.GET.get("s")
        if s:
            queryset = queryset.filter(name__icontains=s)
1139 1140 1141 1142 1143

        sort = self.request.GET.get("sort")
        # remove "-" that means descending order
        # also check if the column name is valid
        if (sort and
1144
            (sort[1:] if sort[0] == "-" else sort)
1145
                in [i.name for i in Instance._meta.fields] + ["pk"]):
1146
            queryset = queryset.order_by(sort)
1147
        return queryset.select_related('owner', 'node')
1148

1149

1150
class NodeList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
1151 1152 1153
    template_name = "dashboard/node-list.html"
    table_class = NodeListTable
    table_pagination = False
1154

1155 1156 1157 1158
    def get_queryset(self):
        return Node.objects.annotate(
            number_of_VMs=Count('instance_set')).select_related('host')

Őry Máté committed
1159

1160 1161 1162 1163 1164 1165 1166
class GroupList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
    template_name = "dashboard/group-list.html"
    model = Group
    table_class = GroupListTable
    table_pagination = False


1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
class GroupUserDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):

    """This stuff deletes the group.
    """
    model = User
    template_name = "dashboard/confirm/base-delete.html"

    def get_template_names(self):
        if self.request.is_ajax():
            return ['dashboard/confirm/ajax-delete.html']
        else:
            return ['dashboard/confirm/base-delete.html']

    def get_context_data(self, **kwargs):
        # this is redundant now, but if we wanna add more to print
        # we'll need this
        context = super(GroupUserDelete, self).get_context_data(**kwargs)
        return context

    # github.com/django/django/blob/master/django/views/generic/edit.py#L245
    def delete(self, request, *args, **kwargs):
        object = self.get_object()

        object.delete()
        success_url = self.get_success_url()
        success_message = _("Group successfully deleted!")

        if request.is_ajax():
            if request.POST.get('redirect').lower() == "true":
                messages.success(request, success_message)
            return HttpResponse(
                json.dumps({'message': success_message}),
                content_type="application/json",
            )
        else:
            messages.success(request, success_message)
            return HttpResponseRedirect(success_url)

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return next
        else:
            return reverse_lazy('dashboard.index')


class GroupDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):

    """This stuff deletes the group.
    """
    model = Group
    template_name = "dashboard/confirm/base-delete.html"

    def get_template_names(self):
        if self.request.is_ajax():
            return ['dashboard/confirm/ajax-delete.html']
        else:
            return ['dashboard/confirm/base-delete.html']

    def get_context_data(self, **kwargs):
        # this is redundant now, but if we wanna add more to print
        # we'll need this
        context = super(GroupDelete, self).get_context_data(**kwargs)
        return context

    # github.com/django/django/blob/master/django/views/generic/edit.py#L245
    def delete(self, request, *args, **kwargs):
        object = self.get_object()

        object.delete()
        success_url = self.get_success_url()
        success_message = _("Group successfully deleted!")

        if request.is_ajax():
            if request.POST.get('redirect').lower() == "true":
                messages.success(request, success_message)
            return HttpResponse(
                json.dumps({'message': success_message}),
                content_type="application/json",
            )
        else:
            messages.success(request, success_message)
            return HttpResponseRedirect(success_url)

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return next
        else:
            return reverse_lazy('dashboard.index')


1259
class VmCreate(LoginRequiredMixin, TemplateView):
1260

1261
    form_class = VmCustomizeForm
1262 1263
    form = None

1264 1265
    def get_template_names(self):
        if self.request.is_ajax():
1266
            return ['dashboard/modal-wrapper.html']
1267
        else:
1268
            return ['dashboard/nojs-wrapper.html']
1269

1270
    def get(self, request, form=None, *args, **kwargs):
1271 1272 1273
        form_error = form is not None
        template = (form.template.pk if form_error
                    else request.GET.get("template"))
1274 1275
        templates = InstanceTemplate.get_objects_with_level('user',
                                                            request.user)
1276 1277 1278 1279
        if form is None and template:
            form = self.form_class(user=request.user,
                                   template=templates.get(pk=template))

1280
        context = self.get_context_data(**kwargs)
1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
        if template:
            context.update({
                'template': 'dashboard/_vm-create-2.html',
                'box_title': _('Customize VM'),
                'ajax_title': False,
                'vm_create_form': form,
                'template_o': templates.get(pk=template),
            })
        else:
            context.update({
                'template': 'dashboard/_vm-create-1.html',
                'box_title': _('Create a VM'),
                'ajax_title': False,
                'templates': templates.all(),
            })
1296
        return self.render_to_response(context)
1297

1298 1299 1300 1301 1302 1303 1304 1305 1306
    def __create_normal(self, request, *args, **kwargs):
        user = request.user
        template = InstanceTemplate.objects.get(
            pk=request.POST.get("template"))

        # permission check
        if not template.has_level(request.user, 'user'):
            raise PermissionDenied()

1307 1308 1309
        instances = [Instance.create_from_template(
            template=template, owner=user)]
        return self.__deploy(request, instances)
1310 1311 1312 1313 1314 1315 1316 1317 1318

    def __create_customized(self, request, *args, **kwargs):
        user = request.user
        form = self.form_class(
            request.POST, user=request.user,
            template=InstanceTemplate.objects.get(
                pk=request.POST.get("template")
            )
        )
1319 1320 1321 1322
        if not form.is_valid():
            return self.get(request, form, *args, **kwargs)
        post = form.cleaned_data

1323 1324 1325
        template = InstanceTemplate.objects.get(pk=post['template'])
        # permission check
        if not template.has_level(user, 'user'):
1326
            raise PermissionDenied()
1327

1328 1329
        if request.user.has_perm('vm.set_resources'):
            ikwargs = {
1330
                'name': post['name'],
1331 1332 1333 1334
                'num_cores': post['cpu_count'],
                'ram_size': post['ram_size'],
                'priority': post['cpu_priority'],
            }
1335 1336
            networks = [InterfaceTemplate(vlan=l, managed=l.managed)
                        for l in post['networks']]
1337
            disks = post['disks']
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349

            ikwargs.update({
                'template': template,
                'owner': user,
                'networks': networks,
                'disks': disks,
            })

            amount = post['amount']
            instances = Instance.mass_create_from_template(amount=amount,
                                                           **ikwargs)
            return self.__deploy(request, instances)
1350
        else:
1351 1352
            raise PermissionDenied()