instance.py 32.4 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 absolute_import, unicode_literals
19
from datetime import timedelta
20
from functools import partial
Őry Máté committed
21
from importlib import import_module
Dudás Ádám committed
22
from logging import getLogger
23
from warnings import warn
24

25
import django.conf
Őry Máté committed
26 27
from django.contrib.auth.models import User
from django.core import signing
Dudás Ádám committed
28
from django.core.exceptions import PermissionDenied
29 30 31
from django.db.models import (BooleanField, CharField, DateTimeField,
                              IntegerField, ForeignKey, Manager,
                              ManyToManyField, permalink, SET_NULL, TextField)
32
from django.db import IntegrityError
33
from django.dispatch import Signal
34
from django.utils import timezone
35
from django.utils.translation import ugettext_lazy as _, ugettext_noop
Dudás Ádám committed
36

37
from model_utils import Choices
38
from model_utils.managers import QueryManager
39
from model_utils.models import TimeStampedModel, StatusModel
40
from taggit.managers import TaggableManager
41

Dudás Ádám committed
42
from acl.models import AclBase
43
from common.models import (
44
    create_readable, HumanReadableException,
45
)
46
from common.operations import OperatedMixin
Dudás Ádám committed
47
from ..tasks import vm_tasks, agent_tasks
48 49
from .activity import (ActivityInProgressError, instance_activity,
                       InstanceActivity)
50
from .common import BaseResourceConfigModel, Lease
51 52
from .network import Interface
from .node import Node, Trait
53

54
logger = getLogger(__name__)
Őry Máté committed
55 56
pre_state_changed = Signal(providing_args=["new_state"])
post_state_changed = Signal(providing_args=["new_state"])
Bach Dániel committed
57 58 59
pwgen = partial(User.objects.make_random_password,
                allowed_chars='abcdefghijklmnopqrstuvwx'
                              'ABCDEFGHIJKLMNOPQRSTUVWX0123456789')
60
scheduler = import_module(name=django.conf.settings.VM_SCHEDULER)
Őry Máté committed
61

62
ACCESS_PROTOCOLS = django.conf.settings.VM_ACCESS_PROTOCOLS
Őry Máté committed
63 64
ACCESS_METHODS = [(key, name) for key, (name, port, transport)
                  in ACCESS_PROTOCOLS.iteritems()]
Bach Dániel committed
65
VNC_PORT_RANGE = (20000, 65536)  # inclusive start, exclusive end
66 67


68 69 70 71 72 73 74 75 76 77 78 79 80 81
def find_unused_port(port_range, used_ports=[]):
    """Find an unused port in the specified range.

    The list of used ports can be specified optionally.

    :param port_range: a tuple representing a port range (w/ exclusive end)
                       e.g. (6000, 7000) represents ports 6000 through 6999
    """
    ports = xrange(*port_range)
    used = set(used_ports)
    unused = (port for port in ports if port not in used)
    return next(unused, None)  # first or None


82
def find_unused_vnc_port():
83 84 85 86 87
    port = find_unused_port(
        port_range=VNC_PORT_RANGE,
        used_ports=Instance.objects.values_list('vnc_port', flat=True))

    if port is None:
88
        raise Exception("No unused port could be found for VNC.")
89 90
    else:
        return port
91 92


93
class VirtualMachineDescModel(BaseResourceConfigModel):
94

95 96 97 98 99 100 101 102
    """Abstract base for virtual machine describing models.
    """
    access_method = CharField(max_length=10, choices=ACCESS_METHODS,
                              verbose_name=_('access method'),
                              help_text=_('Primary remote access method.'))
    boot_menu = BooleanField(verbose_name=_('boot menu'), default=False,
                             help_text=_(
                                 'Show boot device selection menu on boot.'))
Kálmán Viktor committed
103 104
    lease = ForeignKey(Lease, help_text=_("Preferred expiration periods."),
                       verbose_name=_("Lease"))
105 106
    raw_data = TextField(verbose_name=_('raw_data'), blank=True, help_text=_(
        'Additional libvirt domain parameters in XML format.'))
Dudás Ádám committed
107 108 109 110 111
    req_traits = ManyToManyField(Trait, blank=True,
                                 help_text=_("A set of traits required for a "
                                             "node to declare to be suitable "
                                             "for hosting the VM."),
                                 verbose_name=_("required traits"))
112 113 114 115
    system = TextField(verbose_name=_('operating system'),
                       help_text=(_('Name of operating system in '
                                    'format like "%s".') %
                                  'Ubuntu 12.04 LTS Desktop amd64'))
Dudás Ádám committed
116
    tags = TaggableManager(blank=True, verbose_name=_("tags"))
117 118 119 120
    has_agent = BooleanField(verbose_name=_('has agent'), default=True,
                             help_text=_(
                                 'If the machine has agent installed, and '
                                 'the manager should wait for its start.'))
121 122 123 124 125

    class Meta:
        abstract = True


126
class InstanceTemplate(AclBase, VirtualMachineDescModel, TimeStampedModel):
tarokkk committed
127

128 129
    """Virtual machine template.
    """
130 131 132 133 134
    ACL_LEVELS = (
        ('user', _('user')),          # see all details
        ('operator', _('operator')),
        ('owner', _('owner')),        # superuser, can delete, delegate perms
    )
135
    name = CharField(max_length=100, verbose_name=_('name'),
Őry Máté committed
136 137 138 139
                     help_text=_('Human readable name of template.'))
    description = TextField(verbose_name=_('description'), blank=True)
    parent = ForeignKey('self', null=True, blank=True,
                        verbose_name=_('parent template'),
140
                        on_delete=SET_NULL,
Őry Máté committed
141
                        help_text=_('Template which this one is derived of.'))
Bach Dániel committed
142
    disks = ManyToManyField('storage.Disk', verbose_name=_('disks'),
Őry Máté committed
143 144
                            related_name='template_set',
                            help_text=_('Disks which are to be mounted.'))
145
    owner = ForeignKey(User)
146 147

    class Meta:
Őry Máté committed
148 149
        app_label = 'vm'
        db_table = 'vm_instancetemplate'
150
        ordering = ('name', )
Őry Máté committed
151 152
        permissions = (
            ('create_template', _('Can create an instance template.')),
153 154
            ('create_base_template',
             _('Can create an instance template (base).')),
155 156
            ('change_template_resources',
             _('Can change resources of a template.')),
Őry Máté committed
157
        )
158 159 160 161 162 163
        verbose_name = _('template')
        verbose_name_plural = _('templates')

    def __unicode__(self):
        return self.name

164
    @property
165
    def running_instances(self):
166
        """The number of running instances of the template.
167
        """
168
        return sum(1 for i in self.instance_set.all() if i.is_running)
169 170 171

    @property
    def os_type(self):
172
        """The type of the template's operating system.
173 174
        """
        if self.access_method == 'rdp':
175
            return 'windows'
176
        else:
177
            return 'linux'
178

179 180 181 182
    @property
    def is_ready(self):
        return all(disk.is_ready for disk in self.disks)

183 184 185 186 187 188
    def save(self, *args, **kwargs):
        is_new = getattr(self, "pk", None) is None
        super(InstanceTemplate, self).save(*args, **kwargs)
        if is_new:
            self.set_level(self.owner, 'owner')

189 190 191 192
    @permalink
    def get_absolute_url(self):
        return ('dashboard.views.template-detail', None, {'pk': self.pk})

193 194 195
    def remove_disk(self, disk, **kwargs):
        self.disks.remove(disk)

196 197 198 199 200 201
    def destroy_disks(self):
        """Destroy all associated disks.
        """
        for disk in self.disks.all():
            disk.destroy()

202 203 204
    def get_running_instances(self):
        return Instance.active.filter(template=self, status="RUNNING")

205

206
class Instance(AclBase, VirtualMachineDescModel, StatusModel, OperatedMixin,
207
               TimeStampedModel):
tarokkk committed
208

209 210
    """Virtual machine instance.
    """
211 212 213 214 215
    ACL_LEVELS = (
        ('user', _('user')),          # see all details
        ('operator', _('operator')),  # console, networking, change state
        ('owner', _('owner')),        # superuser, can delete, delegate perms
    )
216 217 218 219 220 221 222 223 224
    STATUS = Choices(
        ('NOSTATE', _('no state')),
        ('RUNNING', _('running')),
        ('STOPPED', _('stopped')),
        ('SUSPENDED', _('suspended')),
        ('ERROR', _('error')),
        ('PENDING', _('pending')),
        ('DESTROYED', _('destroyed')),
    )
Őry Máté committed
225
    name = CharField(blank=True, max_length=100, verbose_name=_('name'),
226
                     help_text=_("Human readable name of instance."))
Őry Máté committed
227 228
    description = TextField(blank=True, verbose_name=_('description'))
    template = ForeignKey(InstanceTemplate, blank=True, null=True,
229
                          related_name='instance_set', on_delete=SET_NULL,
230
                          help_text=_("Template the instance derives from."),
Őry Máté committed
231
                          verbose_name=_('template'))
232
    pw = CharField(help_text=_("Original password of the instance."),
Őry Máté committed
233 234 235
                   max_length=20, verbose_name=_('password'))
    time_of_suspend = DateTimeField(blank=True, default=None, null=True,
                                    verbose_name=_('time of suspend'),
236 237
                                    help_text=_("Proposed time of automatic "
                                                "suspension."))
Őry Máté committed
238 239
    time_of_delete = DateTimeField(blank=True, default=None, null=True,
                                   verbose_name=_('time of delete'),
240 241
                                   help_text=_("Proposed time of automatic "
                                               "deletion."))
Őry Máté committed
242 243
    node = ForeignKey(Node, blank=True, null=True,
                      related_name='instance_set',
244
                      help_text=_("Current hypervisor of this instance."),
Őry Máté committed
245
                      verbose_name=_('host node'))
Bach Dániel committed
246
    disks = ManyToManyField('storage.Disk', related_name='instance_set',
247
                            help_text=_("Set of mounted disks."),
Őry Máté committed
248
                            verbose_name=_('disks'))
249 250 251
    vnc_port = IntegerField(blank=True, default=None, null=True,
                            help_text=_("TCP port where VNC console listens."),
                            unique=True, verbose_name=_('vnc_port'))
252
    is_base = BooleanField(default=False)
Őry Máté committed
253
    owner = ForeignKey(User)
254 255 256
    destroyed_at = DateTimeField(blank=True, null=True,
                                 help_text=_("The virtual machine's time of "
                                             "destruction."))
257
    objects = Manager()
258
    active = QueryManager(destroyed_at=None)
259 260

    class Meta:
Őry Máté committed
261 262
        app_label = 'vm'
        db_table = 'vm_instance'
263
        ordering = ('pk', )
264 265 266 267
        permissions = (
            ('access_console', _('Can access the graphical console of a VM.')),
            ('change_resources', _('Can change resources of a running VM.')),
            ('set_resources', _('Can change resources of a new VM.')),
268
            ('create_vm', _('Can create a new VM.')),
269
            ('config_ports', _('Can configure port forwards.')),
Bach Dániel committed
270
            ('recover', _('Can recover a destroyed VM.')),
271
            ('emergency_change_state', _('Can change VM state to NOSTATE.')),
272
        )
273 274 275
        verbose_name = _('instance')
        verbose_name_plural = _('instances')

276
    class InstanceError(HumanReadableException):
277

278 279 280 281 282
        def __init__(self, instance, params=None, level=None, **kwargs):
            kwargs.update(params or {})
            self.instance = kwargs["instance"] = instance
            super(Instance.InstanceError, self).__init__(
                level, self.message, self.message, kwargs)
283

284 285 286
    class InstanceDestroyedError(InstanceError):
        message = ugettext_noop(
            "Instance %(instance)s has already been destroyed.")
287

Őry Máté committed
288 289 290 291
    class NoAgentError(InstanceError):
        message = ugettext_noop(
            "No agent software is running on instance %(instance)s.")

292 293 294 295
    class WrongStateError(InstanceError):
        message = ugettext_noop(
            "Current state (%(state)s) of instance %(instance)s is "
            "inappropriate for the invoked operation.")
296

297 298 299
        def __init__(self, instance, params=None, **kwargs):
            super(Instance.WrongStateError, self).__init__(
                instance, params, state=instance.status)
300

301
    def __unicode__(self):
302
        parts = (self.name, "(" + str(self.id) + ")")
303
        return " ".join(s for s in parts if s != "")
304

305
    @property
306 307 308 309
    def is_console_available(self):
        return self.is_running

    @property
310
    def is_running(self):
Guba Sándor committed
311 312
        """Check if VM is in running state.
        """
313
        return self.status == 'RUNNING'
314 315

    @property
316
    def state(self):
317 318 319 320 321 322 323 324 325 326 327 328
        warn('Use Instance.status (or get_status_display) instead.',
             DeprecationWarning)
        return self.status

    def _update_status(self):
        """Set the proper status of the instance to Instance.status.
        """
        old = self.status
        self.status = self._compute_status()
        if old != self.status:
            logger.info('Status of Instance#%d changed to %s',
                        self.pk, self.status)
329
            self.save(update_fields=('status', ))
330 331 332

    def _compute_status(self):
        """Return the proper status of the instance based on activities.
333
        """
334
        # check special cases
335 336 337 338
        if self.activity_log.filter(activity_code__endswith='migrate',
                                    finished__isnull=True).exists():
            return 'MIGRATING'

339 340 341 342 343 344
        # <<< add checks for special cases before this

        # default case
        acts = self.activity_log.filter(finished__isnull=False,
                                        resultant_state__isnull=False
                                        ).order_by('-finished')[:1]
345
        try:
346
            act = acts[0]
347
        except IndexError:
348 349 350
            return 'NOSTATE'
        else:
            return act.resultant_state
351

Dudás Ádám committed
352 353
    @classmethod
    def create(cls, params, disks, networks, req_traits, tags):
Guba Sándor committed
354 355
        """ Create new Instance object.
        """
Dudás Ádám committed
356 357
        # create instance and do additional setup
        inst = cls(**params)
358

Dudás Ádám committed
359 360 361 362
        # save instance
        inst.full_clean()
        inst.save()
        inst.set_level(inst.owner, 'owner')
363

Dudás Ádám committed
364 365
        def __on_commit(activity):
            activity.resultant_state = 'PENDING'
366

Dudás Ádám committed
367
        with instance_activity(code_suffix='create', instance=inst,
368
                               readable_name=ugettext_noop("create instance"),
Dudás Ádám committed
369 370 371 372 373 374 375 376 377 378 379 380 381
                               on_commit=__on_commit, user=inst.owner) as act:
            # create related entities
            inst.disks.add(*[disk.get_exclusive() for disk in disks])

            for net in networks:
                Interface.create(instance=inst, vlan=net.vlan,
                                 owner=inst.owner, managed=net.managed,
                                 base_activity=act)

            inst.req_traits.add(*req_traits)
            inst.tags.add(*tags)

            return inst
382

383
    @classmethod
384
    def create_from_template(cls, template, owner, disks=None, networks=None,
Dudás Ádám committed
385
                             req_traits=None, tags=None, **kwargs):
386 387 388 389 390
        """Create a new instance based on an InstanceTemplate.

        Can also specify parameters as keyword arguments which should override
        template settings.
        """
391 392 393 394 395 396 397 398 399 400 401 402 403 404
        insts = cls.mass_create_from_template(template, owner, disks=disks,
                                              networks=networks, tags=tags,
                                              req_traits=req_traits, **kwargs)
        return insts[0]

    @classmethod
    def mass_create_from_template(cls, template, owner, amount=1, disks=None,
                                  networks=None, req_traits=None, tags=None,
                                  **kwargs):
        """Mass-create new instances based on an InstanceTemplate.

        Can also specify parameters as keyword arguments which should override
        template settings.
        """
405
        disks = template.disks.all() if disks is None else disks
406

407 408 409
        networks = (template.interface_set.all() if networks is None
                    else networks)

410 411 412 413
        for network in networks:
            if not network.vlan.has_level(owner, 'user'):
                raise PermissionDenied()

Dudás Ádám committed
414 415 416
        req_traits = (template.req_traits.all() if req_traits is None
                      else req_traits)

Dudás Ádám committed
417 418
        tags = template.tags.all() if tags is None else tags

419
        # prepare parameters
Dudás Ádám committed
420 421
        common_fields = ['name', 'description', 'num_cores', 'ram_size',
                         'max_ram_size', 'arch', 'priority', 'boot_menu',
422 423
                         'raw_data', 'lease', 'access_method', 'system',
                         'has_agent']
Dudás Ádám committed
424 425 426
        params = dict(template=template, owner=owner, pw=pwgen())
        params.update([(f, getattr(template, f)) for f in common_fields])
        params.update(kwargs)  # override defaults w/ user supplied values
427 428

        if amount > 1 and '%d' not in params['name']:
429
            params['name'] += ' %d'
Dudás Ádám committed
430

431 432 433 434 435
        customized_params = (dict(params,
                                  name=params['name'].replace('%d', str(i)))
                             for i in xrange(amount))
        return [cls.create(cps, disks, networks, req_traits, tags)
                for cps in customized_params]
436

Dudás Ádám committed
437
    def clean(self, *args, **kwargs):
438
        self.time_of_suspend, self.time_of_delete = self.get_renew_times()
Dudás Ádám committed
439
        super(Instance, self).clean(*args, **kwargs)
440

441 442 443
    def vm_state_changed(self, new_state, new_node=False):
        if new_node is False:  # None would be a valid value
            new_node = self.node
Dudás Ádám committed
444 445
        # log state change
        try:
446 447 448
            act = InstanceActivity.create(
                code_suffix='vm_state_changed',
                readable_name=create_readable(
449 450
                    ugettext_noop("vm state changed to %(state)s on %(node)s"),
                    state=new_state, node=new_node),
451
                instance=self)
Dudás Ádám committed
452 453 454
        except ActivityInProgressError:
            pass  # discard state change if another activity is in progress.
        else:
455 456 457
            if self.node != new_node:
                self.node = new_node
                self.save()
Dudás Ádám committed
458 459 460 461
            act.finished = act.started
            act.resultant_state = new_state
            act.succeeded = True
            act.save()
462

Őry Máté committed
463
    @permalink
464
    def get_absolute_url(self):
465
        return ('dashboard.views.detail', None, {'pk': self.id})
466 467

    @property
468 469 470 471 472 473 474 475 476
    def vm_name(self):
        """Name of the VM instance.

        This is a unique identifier as opposed to the 'name' attribute, which
        is just for display.
        """
        return 'cloud-' + str(self.id)

    @property
477
    def mem_dump(self):
478
        """Return the path and datastore for the memory dump.
479 480 481

        It is always on the first hard drive storage named cloud-<id>.dump
        """
482 483
        try:
            datastore = self.disks.all()[0].datastore
484 485 486 487 488 489
        except IndexError:
            from storage.models import DataStore
            datastore = DataStore.objects.get()

        path = datastore.path + '/' + self.vm_name + '.dump'
        return {'datastore': datastore, 'path': path}
490 491

    @property
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
    def primary_host(self):
        interfaces = self.interface_set.select_related('host')
        hosts = [i.host for i in interfaces if i.host]
        if not hosts:
            return None
        hs = [h for h in hosts if h.ipv6]
        if hs:
            return hs[0]
        hs = [h for h in hosts if not h.shared_ip]
        if hs:
            return hs[0]
        return hosts[0]

    @property
    def ipv4(self):
507 508
        """Primary IPv4 address of the instance.
        """
509 510 511 512 513
        # return self.primary_host.ipv4 if self.primary_host else None
        for i in self.interface_set.all():
            if i.host:
                return i.host.ipv4
        return None
514 515 516

    @property
    def ipv6(self):
517 518
        """Primary IPv6 address of the instance.
        """
519 520 521 522
        return self.primary_host.ipv6 if self.primary_host else None

    @property
    def mac(self):
523 524
        """Primary MAC address of the instance.
        """
525 526 527
        return self.primary_host.mac if self.primary_host else None

    @property
528 529 530 531 532 533 534 535
    def os_type(self):
        """Get the type of the instance's operating system.
        """
        if self.template is None:
            return "unknown"
        else:
            return self.template.os_type

536 537 538 539
    @property
    def waiting(self):
        """Indicates whether the instance's waiting for an operation to finish.
        """
540
        return self.activity_log.filter(finished__isnull=True).exists()
541 542 543 544 545 546 547 548 549 550 551 552 553 554 555

    def get_connect_port(self, use_ipv6=False):
        """Get public port number for default access method.
        """
        port, proto = ACCESS_PROTOCOLS[self.access_method][1:3]
        if self.primary_host:
            endpoints = self.primary_host.get_public_endpoints(port, proto)
            endpoint = endpoints['ipv6'] if use_ipv6 else endpoints['ipv4']
            return endpoint[1] if endpoint else None
        else:
            return None

    def get_connect_host(self, use_ipv6=False):
        """Get public hostname.
        """
556 557
        if not self.primary_host:
            return None
558
        proto = 'ipv6' if use_ipv6 else 'ipv4'
559
        return self.primary_host.get_hostname(proto=proto)
560

561
    def get_connect_command(self, use_ipv6=False):
Guba Sándor committed
562 563
        """Returns a formatted connect string.
        """
564 565 566 567 568 569 570 571 572
        try:
            port = self.get_connect_port(use_ipv6=use_ipv6)
            host = self.get_connect_host(use_ipv6=use_ipv6)
            proto = self.access_method
            if proto == 'rdp':
                return 'rdesktop %(host)s:%(port)d -u cloud -p %(pw)s' % {
                    'port': port, 'proto': proto, 'pw': self.pw,
                    'host': host}
            elif proto == 'ssh':
573
                return ('sshpass -p %(pw)s ssh -o StrictHostKeyChecking=no '
574 575 576 577 578 579
                        'cloud@%(host)s -p %(port)d') % {
                    'port': port, 'proto': proto, 'pw': self.pw,
                    'host': host}
        except:
            return

580 581 582 583 584 585 586
    def get_connect_uri(self, use_ipv6=False):
        """Get access parameters in URI format.
        """
        try:
            port = self.get_connect_port(use_ipv6=use_ipv6)
            host = self.get_connect_host(use_ipv6=use_ipv6)
            proto = self.access_method
587
            return ('circle:%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
588 589
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
590 591 592
        except:
            return

593 594 595 596 597 598 599
    @property
    def short_hostname(self):
        try:
            return self.primary_host.hostname
        except AttributeError:
            return self.vm_name

tarokkk committed
600
    def get_vm_desc(self):
Guba Sándor committed
601 602
        """Serialize Instance object to vmdriver.
        """
tarokkk committed
603
        return {
604
            'name': self.vm_name,
605
            'vcpu': self.num_cores,
606
            'memory': int(self.ram_size) * 1024,  # convert from MiB to KiB
Őry Máté committed
607
            'memory_max': int(self.max_ram_size) * 1024,  # convert MiB to KiB
608 609 610 611 612
            'cpu_share': self.priority,
            'arch': self.arch,
            'boot_menu': self.boot_menu,
            'network_list': [n.get_vmnetwork_desc()
                             for n in self.interface_set.all()],
613 614 615 616 617
            'disk_list': [d.get_vmdisk_desc() for d in self.disks.all()],
            'graphics': {
                'type': 'vnc',
                'listen': '0.0.0.0',
                'passwd': '',
Guba Sándor committed
618
                'port': self.vnc_port
619
            },
620
            'boot_token': signing.dumps(self.id, salt='activate'),
Guba Sándor committed
621
            'raw_data': "" if not self.raw_data else self.raw_data
622
        }
tarokkk committed
623

624
    def get_remote_queue_name(self, queue_id, priority=None):
625 626 627
        """Get the remote worker queue name of this instance with the specified
           queue ID.
        """
628
        if self.node:
629
            return self.node.get_remote_queue_name(queue_id, priority)
630 631
        else:
            raise Node.DoesNotExist()
632

633
    def _is_notified_about_expiration(self):
634 635 636
        last_activity = self.activity_log.latest('pk')
        return (last_activity.activity_code ==
                'vm.Instance.notification_about_expiration')
637 638 639 640 641 642

    def notify_owners_about_expiration(self, again=False):
        """Notify owners about vm expiring soon if they aren't already.

        :param again: Notify already notified owners.
        """
Bach Dániel committed
643 644 645 646 647 648 649

        notification_msg = ugettext_noop(
            'Your instance <a href="%(url)s">%(instance)s</a> is going to '
            'expire. It will be suspended at %(suspend)s and destroyed at '
            '%(delete)s. Please, either <a href="%(token)s">renew</a> '
            'or <a href="%(url)s">destroy</a> it now.')

650 651 652 653 654
        if not again and self._is_notified_about_expiration():
            return False
        success, failed = [], []

        def on_commit(act):
655 656 657 658 659 660 661 662 663 664 665 666 667 668
            if failed:
                act.result = create_readable(ugettext_noop(
                    "%(failed)s notifications failed and %(success) succeeded."
                    " Failed ones are: %(faileds)s."), ugettext_noop(
                    "%(failed)s notifications failed and %(success) succeeded."
                    " Failed ones are: %(faileds_ex)s."),
                    failed=len(failed), success=len(success),
                    faileds=", ".join(a for a, e in failed),
                    faileds_ex=", ".join("%s (%s)" % (a, unicode(e))
                                         for a, e in failed))
            else:
                act.result = create_readable(ugettext_noop(
                    "%(success)s notifications succeeded."),
                    success=len(success), successes=success)
669 670

        with instance_activity('notification_about_expiration', instance=self,
671 672
                               readable_name=ugettext_noop(
                                   "notify owner about expiration"),
673
                               on_commit=on_commit):
674
            from dashboard.views import VmRenewView, absolute_url
675 676 677 678 679
            level = self.get_level_object("owner")
            for u, ulevel in self.get_users_with_level(level__pk=level.pk):
                try:
                    token = VmRenewView.get_token_url(self, u)
                    u.profile.notify(
Bach Dániel committed
680 681 682 683
                        ugettext_noop('%(instance)s expiring soon'),
                        notification_msg, url=self.get_absolute_url(),
                        instance=self, suspend=self.time_of_suspend,
                        token=token, delete=self.time_of_delete)
684 685 686 687
                except Exception as e:
                    failed.append((u, e))
                else:
                    success.append(u)
688
            if self.status == "RUNNING":
689 690
                token = absolute_url(
                    VmRenewView.get_token_url(self, self.owner))
691 692 693
                queue = self.get_remote_queue_name("agent")
                agent_tasks.send_expiration.apply_async(
                    queue=queue, args=(self.vm_name, token))
694 695
        return True

696 697 698 699 700 701 702
    def is_expiring(self, threshold=0.1):
        """Returns if an instance will expire soon.

        Soon means that the time of suspend or delete comes in 10% of the
        interval what the Lease allows. This rate is configurable with the
        only parameter, threshold (0.1 = 10% by default).
        """
Bach Dániel committed
703 704
        return (self._is_suspend_expiring(threshold) or
                self._is_delete_expiring(threshold))
705 706 707

    def _is_suspend_expiring(self, threshold=0.1):
        interval = self.lease.suspend_interval
Bach Dániel committed
708 709 710
        if self.time_of_suspend is not None and interval is not None:
            limit = timezone.now() + timedelta(seconds=(
                threshold * self.lease.suspend_interval.total_seconds()))
711 712 713 714 715 716
            return limit > self.time_of_suspend
        else:
            return False

    def _is_delete_expiring(self, threshold=0.1):
        interval = self.lease.delete_interval
Bach Dániel committed
717 718 719
        if self.time_of_delete is not None and interval is not None:
            limit = timezone.now() + timedelta(seconds=(
                threshold * self.lease.delete_interval.total_seconds()))
720 721 722 723
            return limit > self.time_of_delete
        else:
            return False

724
    def get_renew_times(self, lease=None):
725 726
        """Returns new suspend and delete times if renew would be called.
        """
727 728
        if lease is None:
            lease = self.lease
729
        return (
730 731
            timezone.now() + lease.suspend_interval,
            timezone.now() + lease.delete_interval)
Dudás Ádám committed
732

733 734 735 736
    def select_node(self):
        """Returns the node the VM should be deployed or migrated to.
        """
        return scheduler.select_node(self, Node.objects.all())
737

Dudás Ádám committed
738 739
    def destroy_disks(self):
        """Destroy all associated disks.
740
        """
Dudás Ádám committed
741 742
        for disk in self.disks.all():
            disk.destroy()
743

Dudás Ádám committed
744 745
    def deploy_net(self):
        """Deploy all associated network interfaces.
746
        """
Dudás Ádám committed
747 748
        for net in self.interface_set.all():
            net.deploy()
749

Dudás Ádám committed
750 751
    def destroy_net(self):
        """Destroy all associated network interfaces.
752
        """
Dudás Ádám committed
753 754
        for net in self.interface_set.all():
            net.destroy()
755

Dudás Ádám committed
756 757
    def shutdown_net(self):
        """Shutdown all associated network interfaces.
758
        """
Dudás Ádám committed
759 760
        for net in self.interface_set.all():
            net.shutdown()
761

Dudás Ádám committed
762 763 764
    def allocate_node(self):
        if self.node is None:
            self.node = self.select_node()
765 766
            self.save()

Dudás Ádám committed
767 768 769 770
    def yield_node(self):
        if self.node is not None:
            self.node = None
            self.save()
Guba Sándor committed
771

Dudás Ádám committed
772 773
    def allocate_vnc_port(self):
        if self.vnc_port is None:
774 775 776 777 778 779 780 781 782 783
            while True:
                try:
                    self.vnc_port = find_unused_vnc_port()
                    self.save()
                except IntegrityError:
                    # Another thread took this port get another one
                    logger.debug("Port %s is in use.", self.vnc_port)
                    pass
                else:
                    break
784

Dudás Ádám committed
785 786 787 788
    def yield_vnc_port(self):
        if self.vnc_port is not None:
            self.vnc_port = None
            self.save()
789 790 791

    def get_status_icon(self):
        return {
792 793 794 795 796 797 798
            'NOSTATE': 'fa-rocket',
            'RUNNING': 'fa-play',
            'STOPPED': 'fa-stop',
            'SUSPENDED': 'fa-pause',
            'ERROR': 'fa-warning',
            'PENDING': 'fa-rocket',
            'DESTROYED': 'fa-trash-o',
799 800
            'MIGRATING': 'fa-truck migrating-icon'
        }.get(self.status, 'fa-question')
801 802 803 804 805

    def get_activities(self, user=None):
        acts = (self.activity_log.filter(parent=None).
                order_by('-started').
                select_related('user').prefetch_related('children'))
806 807 808 809 810
        # Check latest activity for percentage
        for i in acts:
            if i.has_percentage():
                i.has_percent = True
                i.percentage = i.get_percentage()
811 812 813 814
        if user is not None:
            for i in acts:
                i.is_abortable_for_user = partial(i.is_abortable_for,
                                                  user=user)
815
        return acts
816

817
    def get_merged_activities(self, user=None):
818
        whitelist = ("create_disk", "download_disk")
819
        acts = self.get_activities(user)
820 821 822 823 824
        merged_acts = []
        latest = None

        for a in acts:
            if (latest == a.activity_code and
825
                    merged_acts[-1].result_data == a.result_data and
826
                    a.finished and merged_acts[-1].finished and
827
                    a.user == merged_acts[-1].user and
828 829
                    (merged_acts[-1].finished - a.finished).days < 7 and
                    not a.activity_code.endswith(whitelist)):
830 831 832 833 834 835 836 837
                merged_acts[-1].times += 1
            else:
                merged_acts.append(a)
                merged_acts[-1].times = 1
            latest = a.activity_code

        return merged_acts

838
    def get_screenshot(self, timeout=5):
Kálmán Viktor committed
839
        queue_name = self.get_remote_queue_name("vm", "fast")
840 841 842
        return vm_tasks.screenshot.apply_async(args=[self.vm_name],
                                               queue=queue_name
                                               ).get(timeout=timeout)
843 844 845 846

    def get_latest_activity_in_progress(self):
        try:
            return InstanceActivity.objects.filter(
847
                instance=self, succeeded=None, parent=None).latest("started")
848 849
        except InstanceActivity.DoesNotExist:
            return None
850 851 852 853 854

    def is_in_status_change(self):
        latest = self.get_latest_activity_in_progress()
        return (latest and latest.resultant_state is not None
                and self.status != latest.resultant_state)
855 856 857 858

    @property
    def metric_prefix(self):
        return 'vm.%s' % self.vm_name