views.py 89 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,
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
class TemplateCreate(SuccessMessageMixin, CreateView):
    model = InstanceTemplate
    form_class = TemplateForm

872 873 874 875 876 877 878 879 880 881
    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({
882
            'box_title': _("Create a new base VM"),
883 884
            'ajax_title': False,
            'template': "dashboard/_template-create-2.html",
885
            'leases': Lease.objects.count()
886 887 888
        })
        return context

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

893 894 895 896 897 898
        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)
899
        kwargs['user'] = self.request.user
900 901
        return kwargs

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

        form = self.form_class(request.POST, user=request.user)
907 908
        if not form.is_valid():
            return self.get(request, form, *args, **kwargs)
909
        else:
910 911
            post = form.cleaned_data

912 913
            networks = self.__create_networks(post.pop("networks"),
                                              request.user)
914
            post.pop("parent")
915
            parent_type = post.pop("parent_type")
916
            post['max_ram_size'] = post['ram_size']
917 918 919 920

            # 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)
921 922 923
                inst = Instance.create_from_template(template=template,
                                                     networks=networks,
                                                     **post)
924
                inst.deploy_async()
925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941
                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!"
                                         ))
942

943
            return redirect("%s#resources" % inst.get_absolute_url())
944

945 946
        return super(TemplateCreate, self).post(self, request, args, kwargs)

947
    def __create_networks(self, vlans, user):
948 949
        networks = []
        for v in vlans:
950 951
            if not v.has_level(user, "user"):
                raise PermissionDenied()
952 953 954
            networks.append(InterfaceTemplate(vlan=v, managed=v.managed))
        return networks

955 956 957 958
    def get_success_url(self):
        return reverse_lazy("dashboard.views.template-list")


959
class TemplateDetail(LoginRequiredMixin, SuccessMessageMixin, UpdateView):
960
    model = InstanceTemplate
961 962 963
    template_name = "dashboard/template-edit.html"
    form_class = TemplateForm
    success_message = _("Successfully modified template!")
964 965

    def get(self, request, *args, **kwargs):
966
        template = self.get_object()
967
        if not template.has_level(request.user, 'user'):
968
            raise PermissionDenied()
969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989
        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:
990 991
            return super(TemplateDetail, self).get(request, *args, **kwargs)

992
    def get_context_data(self, **kwargs):
993
        obj = self.get_object()
994
        context = super(TemplateDetail, self).get_context_data(**kwargs)
995 996
        context['acl'] = get_vm_acl_data(obj)
        context['disks'] = obj.disks.all()
997
        context['disk_add_form'] = DiskAddForm(
998
            user=self.request.user,
999
            is_template=True,
1000
            object_pk=obj.pk,
1001 1002
            prefix="disk",
        )
1003 1004
        return context

1005 1006 1007 1008
    def get_success_url(self):
        return reverse_lazy("dashboard.views.template-detail",
                            kwargs=self.kwargs)

1009 1010 1011 1012 1013 1014 1015
    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()
1016 1017 1018
        for network in self.get_object().interface_set.all():
            if not network.vlan.has_level(request.user, "user"):
                raise PermissionDenied()
1019 1020
        return super(TemplateDetail, self).post(self, request, args, kwargs)

1021 1022 1023 1024 1025
    def get_form_kwargs(self):
        kwargs = super(TemplateDetail, self).get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs

1026

1027
class TemplateList(LoginRequiredMixin, SingleTableView):
1028 1029 1030 1031 1032 1033 1034
    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)
1035 1036
        context['lease_table'] = LeaseListTable(Lease.objects.all(),
                                                request=self.request)
1037
        return context
1038

1039 1040 1041 1042 1043 1044
    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()

1045

1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
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)


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

1080 1081
    def get(self, *args, **kwargs):
        if self.request.is_ajax():
1082 1083 1084 1085
            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(
1086
                destroyed_at=None).all()
1087 1088 1089
            instances = [{
                'pk': i.pk,
                'name': i.name,
1090 1091 1092
                'icon': i.get_status_icon(),
                'host': "" if not i.primary_host else i.primary_host.hostname,
                'status': i.get_status_display(),
1093
                'fav': i.pk in favs} for i in instances]
1094
            return HttpResponse(
1095
                json.dumps(list(instances)),  # instances is ValuesQuerySet
1096 1097 1098 1099 1100
                content_type="application/json",
            )
        else:
            return super(VmList, self).get(*args, **kwargs)

1101
    def get_queryset(self):
1102
        logger.debug('VmList.get_queryset() called. User: %s',
1103
                     unicode(self.request.user))
1104
        queryset = Instance.get_objects_with_level(
1105
            'user', self.request.user).filter(destroyed_at=None)
1106 1107 1108
        s = self.request.GET.get("s")
        if s:
            queryset = queryset.filter(name__icontains=s)
1109 1110 1111 1112 1113

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

1119

1120
class NodeList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
1121 1122 1123
    template_name = "dashboard/node-list.html"
    table_class = NodeListTable
    table_pagination = False
1124

1125 1126 1127 1128
    def get_queryset(self):
        return Node.objects.annotate(
            number_of_VMs=Count('instance_set')).select_related('host')

Őry Máté committed
1129

1130 1131 1132 1133 1134 1135 1136
class GroupList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
    template_name = "dashboard/group-list.html"
    model = Group
    table_class = GroupListTable
    table_pagination = False


1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 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
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')


1229
class VmCreate(LoginRequiredMixin, TemplateView):
1230

1231
    form_class = VmCustomizeForm
1232 1233
    form = None

1234 1235
    def get_template_names(self):
        if self.request.is_ajax():
1236
            return ['dashboard/modal-wrapper.html']
1237
        else:
1238
            return ['dashboard/nojs-wrapper.html']
1239

1240
    def get(self, request, form=None, *args, **kwargs):
1241 1242 1243
        form_error = form is not None
        template = (form.template.pk if form_error
                    else request.GET.get("template"))
1244 1245
        templates = InstanceTemplate.get_objects_with_level('user',
                                                            request.user)
1246 1247 1248 1249
        if form is None and template:
            form = self.form_class(user=request.user,
                                   template=templates.get(pk=template))

1250
        context = self.get_context_data(**kwargs)
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
        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(),
            })
1266
        return self.render_to_response(context)
1267

1268 1269 1270 1271 1272 1273 1274 1275 1276
    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()

1277 1278 1279
        instances = [Instance.create_from_template(
            template=template, owner=user)]
        return self.__deploy(request, instances)
1280 1281 1282 1283 1284 1285 1286 1287 1288

    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")
            )
        )
1289 1290 1291 1292
        if not form.is_valid():
            return self.get(request, form, *args, **kwargs)
        post = form.cleaned_data

1293 1294 1295
        template = InstanceTemplate.objects.get(pk=post['template'])
        # permission check
        if not template.has_level(user, 'user'):
1296
            raise PermissionDenied()
1297

1298 1299
        if request.user.has_perm('vm.set_resources'):
            ikwargs = {
1300
                'name': post['name'],
1301 1302 1303 1304
                'num_cores': post['cpu_count'],
                'ram_size': post['ram_size'],
                'priority': post['cpu_priority'],
            }
1305 1306
            networks = [InterfaceTemplate(vlan=l, managed=l.managed)
                        for l in post['networks']]
1307
            disks = post['disks']
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319

            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)
1320
        else:
1321 1322
            raise PermissionDenied()

1323 1324
    def __deploy(self, request, instances, *args, **kwargs):
        for i in instances:
Dudás Ádám committed
1325
            i.deploy.async(user=request.user)
1326 1327 1328 1329 1330 1331 1332 1333 1334

        if len(instances) > 1:
            messages.success(request, _("Successfully created %d VMs!" %
                                        len(instances)))
            path = reverse("dashboard.index")
        else:
            messages.success(request, _("VM successfully created!"))
            path = instances[0].get_absolute_url()

1335
        if request.is_ajax():
1336 1337
            return HttpResponse(json.dumps({'redirect': path}),
                                content_type="application/json")