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

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

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

Dudás Ádám committed
43
from acl.models import AclBase
44
from common.models import (
45
    activitycontextimpl, create_readable, HumanReadableException,
46
)
47
from common.operations import OperatedMixin
Bach Dániel committed
48
from ..tasks import agent_tasks
49
from .activity import (ActivityInProgressError, 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
pwgen = partial(User.objects.make_random_password,
                allowed_chars='abcdefghijklmnopqrstuvwx'
59
                              'ABCDEFGHIJKLMNOPQRSTUVWX123456789')
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
    system = TextField(verbose_name=_('operating system'),
Bach Dániel committed
113 114
                       help_text=(_('Name of operating system in format like '
                                    '"Ubuntu 12.04 LTS Desktop amd64".')))
Dudás Ádám committed
115
    tags = TaggableManager(blank=True, verbose_name=_("tags"))
116 117 118 119
    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.'))
120 121 122 123 124

    class Meta:
        abstract = True


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

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

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

    def __unicode__(self):
        return self.name

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

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

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

182 183 184 185 186 187
    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')

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

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

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

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

204

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

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

    class Meta:
Őry Máté committed
260 261
        app_label = 'vm'
        db_table = 'vm_instance'
262
        ordering = ('pk', )
263 264 265 266
        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.')),
267
            ('create_vm', _('Can create a new VM.')),
268
            ('redeploy', _('Can redeploy a 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.
        """
356 357 358 359 360 361

        # permission check
        for network in networks:
            if not network.vlan.has_level(params['owner'], 'user'):
                raise PermissionDenied()

Dudás Ádám committed
362 363
        # create instance and do additional setup
        inst = cls(**params)
364

Dudás Ádám committed
365 366 367 368
        # save instance
        inst.full_clean()
        inst.save()
        inst.set_level(inst.owner, 'owner')
369

Dudás Ádám committed
370 371
        def __on_commit(activity):
            activity.resultant_state = 'PENDING'
372

373 374 375
        with inst.activity(code_suffix='create',
                           readable_name=ugettext_noop("create instance"),
                           on_commit=__on_commit, user=inst.owner) as act:
Dudás Ádám committed
376 377 378 379 380 381 382 383 384 385 386 387
            # 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
388

389
    @classmethod
390
    def create_from_template(cls, template, owner, disks=None, networks=None,
Dudás Ádám committed
391
                             req_traits=None, tags=None, **kwargs):
392 393 394 395 396
        """Create a new instance based on an InstanceTemplate.

        Can also specify parameters as keyword arguments which should override
        template settings.
        """
397 398 399 400 401 402 403 404 405 406 407 408 409 410
        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.
        """
411
        disks = template.disks.all() if disks is None else disks
412

413 414 415
        networks = (template.interface_set.all() if networks is None
                    else networks)

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

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

421
        # prepare parameters
Dudás Ádám committed
422 423
        common_fields = ['name', 'description', 'num_cores', 'ram_size',
                         'max_ram_size', 'arch', 'priority', 'boot_menu',
424 425
                         'raw_data', 'lease', 'access_method', 'system',
                         'has_agent']
Dudás Ádám committed
426 427 428
        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
429 430

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

433 434 435 436 437
        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]
438

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

443 444 445
    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
446 447
        # log state change
        try:
448 449 450
            act = InstanceActivity.create(
                code_suffix='vm_state_changed',
                readable_name=create_readable(
451 452
                    ugettext_noop("vm state changed to %(state)s on %(node)s"),
                    state=new_state, node=new_node),
453
                instance=self)
Dudás Ádám committed
454 455 456
        except ActivityInProgressError:
            pass  # discard state change if another activity is in progress.
        else:
457 458 459
            if self.node != new_node:
                self.node = new_node
                self.save()
Dudás Ádám committed
460 461 462 463
            act.finished = act.started
            act.resultant_state = new_state
            act.succeeded = True
            act.save()
464

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

    @property
470 471 472 473 474 475 476 477 478
    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
479
    def mem_dump(self):
480
        """Return the path and datastore for the memory dump.
481 482 483

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

        path = datastore.path + '/' + self.vm_name + '.dump'
        return {'datastore': datastore, 'path': path}
492 493

    @property
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
    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):
509 510
        """Primary IPv4 address of the instance.
        """
511 512 513 514 515
        # 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
516 517 518

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

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

    @property
530 531 532 533 534 535 536 537
    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

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

    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.
        """
558 559
        if not self.primary_host:
            return None
560
        proto = 'ipv6' if use_ipv6 else 'ipv4'
561
        return self.primary_host.get_hostname(proto=proto)
562

563
    def get_connect_command(self, use_ipv6=False):
Guba Sándor committed
564 565
        """Returns a formatted connect string.
        """
566 567 568 569 570 571 572 573 574
        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':
575
                return ('sshpass -p %(pw)s ssh -o StrictHostKeyChecking=no '
576 577 578 579 580 581
                        'cloud@%(host)s -p %(port)d') % {
                    'port': port, 'proto': proto, 'pw': self.pw,
                    'host': host}
        except:
            return

582 583 584 585 586 587 588
    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
589
            return ('circle:%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
590 591
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
592 593 594
        except:
            return

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

tarokkk committed
602
    def get_vm_desc(self):
Guba Sándor committed
603 604
        """Serialize Instance object to vmdriver.
        """
tarokkk committed
605
        return {
606
            'name': self.vm_name,
607
            'vcpu': self.num_cores,
608
            'memory': int(self.ram_size) * 1024,  # convert from MiB to KiB
Őry Máté committed
609
            'memory_max': int(self.max_ram_size) * 1024,  # convert MiB to KiB
610 611 612 613 614
            '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()],
615 616 617 618 619
            '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
620
                'port': self.vnc_port
621
            },
622
            'boot_token': signing.dumps(self.id, salt='activate'),
Guba Sándor committed
623
            'raw_data': "" if not self.raw_data else self.raw_data
624
        }
tarokkk committed
625

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

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

    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
645 646 647 648 649 650 651

        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.')

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

        def on_commit(act):
657 658 659 660 661 662 663 664 665 666 667 668 669 670
            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)
671

672 673 674 675
        with self.activity('notification_about_expiration',
                           readable_name=ugettext_noop(
                               "notify owner about expiration"),
                           on_commit=on_commit):
676
            from dashboard.views import VmRenewView, absolute_url
677 678 679 680 681
            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
682 683 684 685
                        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)
686 687 688 689
                except Exception as e:
                    failed.append((u, e))
                else:
                    success.append(u)
690
            if self.status == "RUNNING":
691 692
                token = absolute_url(
                    VmRenewView.get_token_url(self, self.owner))
693 694 695
                queue = self.get_remote_queue_name("agent")
                agent_tasks.send_expiration.apply_async(
                    queue=queue, args=(self.vm_name, token))
696 697
        return True

698 699 700 701 702 703 704
    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
705 706
        return (self._is_suspend_expiring(threshold) or
                self._is_delete_expiring(threshold))
707 708 709

    def _is_suspend_expiring(self, threshold=0.1):
        interval = self.lease.suspend_interval
Bach Dániel committed
710 711 712
        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()))
713 714 715 716 717 718
            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
719 720 721
        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()))
722 723 724 725
            return limit > self.time_of_delete
        else:
            return False

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

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

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

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

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

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

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

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

Dudás Ádám committed
775 776
    def allocate_vnc_port(self):
        if self.vnc_port is None:
777 778 779 780 781 782 783 784 785 786
            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
787

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

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

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

820
    def get_merged_activities(self, user=None):
821 822 823
        whitelist = ("create_disk", "download_disk", "remove_disk",
                     "add_port", "remove_port",
                     "add_interface", "remove_interface")
824
        acts = self.get_activities(user)
825 826 827 828 829
        merged_acts = []
        latest = None

        for a in acts:
            if (latest == a.activity_code and
830
                    merged_acts[-1].result_data == a.result_data and
831
                    a.finished and merged_acts[-1].finished and
832
                    a.user == merged_acts[-1].user and
833 834
                    (merged_acts[-1].finished - a.finished).days < 7 and
                    not a.activity_code.endswith(whitelist)):
835 836 837 838 839 840 841 842
                merged_acts[-1].times += 1
            else:
                merged_acts.append(a)
                merged_acts[-1].times = 1
            latest = a.activity_code

        return merged_acts

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

    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)
854 855 856 857

    @property
    def metric_prefix(self):
        return 'vm.%s' % self.vm_name
858 859 860 861 862 863 864 865 866 867 868 869 870 871

    @contextmanager
    def activity(self, code_suffix, readable_name, on_abort=None,
                 on_commit=None, task_uuid=None, user=None,
                 concurrency_check=True, resultant_state=None):
        """Create a transactional context for an instance activity.
        """
        if not readable_name:
            warn("Set readable_name", stacklevel=3)
        act = InstanceActivity.create(
            code_suffix=code_suffix, instance=self, task_uuid=task_uuid,
            user=user, concurrency_check=concurrency_check,
            readable_name=readable_name, resultant_state=resultant_state)
        return activitycontextimpl(act, on_abort=on_abort, on_commit=on_commit)