instance.py 37.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 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
Dudás Ádám committed
23
from string import ascii_lowercase
24
from warnings import warn
25

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

39 40
from model_utils import Choices
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 45 46
from common.models import (
    create_readable, HumanReadableException, humanize_exception
)
47
from common.operations import OperatedMixin
Dudás Ádám committed
48
from ..tasks import vm_tasks, agent_tasks
49 50
from .activity import (ActivityInProgressError, instance_activity,
                       InstanceActivity)
51
from .common import BaseResourceConfigModel, Lease
52 53
from .network import Interface
from .node import Node, Trait
54

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

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


69 70 71 72 73 74 75 76 77 78 79 80 81 82
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


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

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


94
class InstanceActiveManager(Manager):
Dudás Ádám committed
95

96 97
    def get_query_set(self):
        return super(InstanceActiveManager,
98
                     self).get_query_set().filter(destroyed_at=None)
99 100


101
class VirtualMachineDescModel(BaseResourceConfigModel):
102

103 104 105 106 107 108 109 110
    """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
111 112
    lease = ForeignKey(Lease, help_text=_("Preferred expiration periods."),
                       verbose_name=_("Lease"))
113 114
    raw_data = TextField(verbose_name=_('raw_data'), blank=True, help_text=_(
        'Additional libvirt domain parameters in XML format.'))
Dudás Ádám committed
115 116 117 118 119
    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"))
120 121 122 123
    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
124
    tags = TaggableManager(blank=True, verbose_name=_("tags"))
125 126 127 128 129

    class Meta:
        abstract = True


130
class InstanceTemplate(AclBase, VirtualMachineDescModel, TimeStampedModel):
tarokkk committed
131

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

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

    def __unicode__(self):
        return self.name

168
    @property
169
    def running_instances(self):
170
        """The number of running instances of the template.
171
        """
172
        return sum(1 for i in self.instance_set.all() if i.is_running)
173 174 175

    @property
    def os_type(self):
176
        """The type of the template's operating system.
177 178
        """
        if self.access_method == 'rdp':
179
            return 'windows'
180
        else:
181
            return 'linux'
182

183 184 185 186
    @property
    def is_ready(self):
        return all(disk.is_ready for disk in self.disks)

187 188 189 190 191 192
    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')

193 194 195 196
    @permalink
    def get_absolute_url(self):
        return ('dashboard.views.template-detail', None, {'pk': self.pk})

197 198 199
    def remove_disk(self, disk, **kwargs):
        self.disks.remove(disk)

200 201 202 203 204 205
    def destroy_disks(self):
        """Destroy all associated disks.
        """
        for disk in self.disks.all():
            disk.destroy()

206 207 208
    def get_running_instances(self):
        return Instance.active.filter(template=self, status="RUNNING")

209

210
class Instance(AclBase, VirtualMachineDescModel, StatusModel, OperatedMixin,
211
               TimeStampedModel):
tarokkk committed
212

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

    class Meta:
Őry Máté committed
269 270
        app_label = 'vm'
        db_table = 'vm_instance'
271
        ordering = ('pk', )
272 273 274 275
        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.')),
276
            ('create_vm', _('Can create a new VM.')),
277
            ('config_ports', _('Can configure port forwards.')),
Bach Dániel committed
278
            ('recover', _('Can recover a destroyed VM.')),
279
            ('emergency_change_state', _('Can change VM state to NOSTATE.')),
280
        )
281 282 283
        verbose_name = _('instance')
        verbose_name_plural = _('instances')

284
    class InstanceError(HumanReadableException):
285

286 287 288 289 290
        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)
291

292 293 294
    class InstanceDestroyedError(InstanceError):
        message = ugettext_noop(
            "Instance %(instance)s has already been destroyed.")
295

Őry Máté committed
296 297 298 299
    class NoAgentError(InstanceError):
        message = ugettext_noop(
            "No agent software is running on instance %(instance)s.")

300 301 302 303
    class WrongStateError(InstanceError):
        message = ugettext_noop(
            "Current state (%(state)s) of instance %(instance)s is "
            "inappropriate for the invoked operation.")
304

305 306 307
        def __init__(self, instance, params=None, **kwargs):
            super(Instance.WrongStateError, self).__init__(
                instance, params, state=instance.status)
308

309
    def __unicode__(self):
310
        parts = (self.name, "(" + str(self.id) + ")")
311
        return " ".join(s for s in parts if s != "")
312

313
    @property
314 315 316 317
    def is_console_available(self):
        return self.is_running

    @property
318
    def is_running(self):
Guba Sándor committed
319 320
        """Check if VM is in running state.
        """
321
        return self.status == 'RUNNING'
322 323

    @property
324
    def state(self):
325 326 327 328 329 330 331 332 333 334 335 336
        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)
337
            self.save(update_fields=('status', ))
338 339 340

    def _compute_status(self):
        """Return the proper status of the instance based on activities.
341
        """
342
        # check special cases
343 344 345 346
        if self.activity_log.filter(activity_code__endswith='migrate',
                                    finished__isnull=True).exists():
            return 'MIGRATING'

347 348 349 350 351 352
        # <<< 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]
353
        try:
354
            act = acts[0]
355
        except IndexError:
356 357 358
            return 'NOSTATE'
        else:
            return act.resultant_state
359

Dudás Ádám committed
360 361
    @classmethod
    def create(cls, params, disks, networks, req_traits, tags):
Guba Sándor committed
362 363
        """ Create new Instance object.
        """
Dudás Ádám committed
364 365
        # create instance and do additional setup
        inst = cls(**params)
366

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

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

Dudás Ádám committed
375
        with instance_activity(code_suffix='create', instance=inst,
376
                               readable_name=ugettext_noop("create instance"),
Dudás Ádám committed
377 378 379 380 381 382 383 384 385 386 387 388 389
                               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
390

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

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

415 416 417
        networks = (template.interface_set.all() if networks is None
                    else networks)

418 419 420 421
        for network in networks:
            if not network.vlan.has_level(owner, 'user'):
                raise PermissionDenied()

Dudás Ádám committed
422 423 424
        req_traits = (template.req_traits.all() if req_traits is None
                      else req_traits)

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

427
        # prepare parameters
Dudás Ádám committed
428 429
        common_fields = ['name', 'description', 'num_cores', 'ram_size',
                         'max_ram_size', 'arch', 'priority', 'boot_menu',
430
                         'raw_data', 'lease', 'access_method', 'system']
Dudás Ádám committed
431 432 433
        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
434 435

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

438 439 440 441 442
        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]
443

Dudás Ádám committed
444
    def clean(self, *args, **kwargs):
445
        self.time_of_suspend, self.time_of_delete = self.get_renew_times()
Dudás Ádám committed
446
        super(Instance, self).clean(*args, **kwargs)
447

Dudás Ádám committed
448 449 450
    def vm_state_changed(self, new_state):
        # log state change
        try:
451 452 453 454 455 456
            act = InstanceActivity.create(
                code_suffix='vm_state_changed',
                readable_name=create_readable(
                    ugettext_noop("vm state changed to %(state)s"),
                    state=new_state),
                instance=self)
Dudás Ádám committed
457 458 459
        except ActivityInProgressError:
            pass  # discard state change if another activity is in progress.
        else:
460 461 462 463
            if new_state == 'STOPPED':
                self.vnc_port = None
                self.node = None
                self.save()
Dudás Ádám committed
464 465 466 467
            act.finished = act.started
            act.resultant_state = new_state
            act.succeeded = True
            act.save()
468

Őry Máté committed
469
    @permalink
470
    def get_absolute_url(self):
471
        return ('dashboard.views.detail', None, {'pk': self.id})
472 473

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

        It is always on the first hard drive storage named cloud-<id>.dump
        """
488 489 490 491 492 493 494
        try:
            datastore = self.disks.all()[0].datastore
        except:
            return None
        else:
            path = datastore.path + '/' + self.vm_name + '.dump'
            return {'datastore': datastore, 'path': path}
495 496

    @property
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
    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):
512 513
        """Primary IPv4 address of the instance.
        """
514 515 516 517
        return self.primary_host.ipv4 if self.primary_host else None

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

    @property
    def mac(self):
524 525
        """Primary MAC address of the instance.
        """
526 527 528 529 530 531 532 533 534 535 536
        return self.primary_host.mac if self.primary_host else None

    @property
    def uptime(self):
        """Uptime of the instance.
        """
        if self.active_since:
            return timezone.now() - self.active_since
        else:
            return timedelta()  # zero

537 538 539 540 541 542 543 544 545
    @property
    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

546 547 548 549 550 551 552 553 554 555 556
    def get_age(self):
        """Deprecated. Use uptime instead.

        Get age of VM in seconds.
        """
        return self.uptime.seconds

    @property
    def waiting(self):
        """Indicates whether the instance's waiting for an operation to finish.
        """
557
        return self.activity_log.filter(finished__isnull=True).exists()
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572

    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.
        """
573 574
        if not self.primary_host:
            return None
575
        proto = 'ipv6' if use_ipv6 else 'ipv4'
576
        return self.primary_host.get_hostname(proto=proto)
577

578
    def get_connect_command(self, use_ipv6=False):
Guba Sándor committed
579 580
        """Returns a formatted connect string.
        """
581 582 583 584 585 586 587 588 589
        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':
590
                return ('sshpass -p %(pw)s ssh -o StrictHostKeyChecking=no '
591 592 593 594 595 596
                        'cloud@%(host)s -p %(port)d') % {
                    'port': port, 'proto': proto, 'pw': self.pw,
                    'host': host}
        except:
            return

597 598 599 600 601 602 603 604 605
    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
            if proto == 'ssh':
                proto = 'sshterm'
606 607 608
            return ('%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
609 610 611
        except:
            return

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

636
    def get_remote_queue_name(self, queue_id, priority=None):
637 638 639
        """Get the remote worker queue name of this instance with the specified
           queue ID.
        """
640
        if self.node:
641
            return self.node.get_remote_queue_name(queue_id, priority)
642 643
        else:
            raise Node.DoesNotExist()
644

645
    def _is_notified_about_expiration(self):
646 647 648
        last_activity = self.activity_log.latest('pk')
        return (last_activity.activity_code ==
                'vm.Instance.notification_about_expiration')
649 650 651 652 653 654

    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
655 656 657 658 659 660 661

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

662 663 664 665 666
        if not again and self._is_notified_about_expiration():
            return False
        success, failed = [], []

        def on_commit(act):
667 668 669 670 671 672 673 674 675 676 677 678 679 680
            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)
681 682

        with instance_activity('notification_about_expiration', instance=self,
683 684
                               readable_name=ugettext_noop(
                                   "notify owner about expiration"),
685
                               on_commit=on_commit):
686
            from dashboard.views import VmRenewView, absolute_url
687 688 689 690 691
            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
692 693 694 695
                        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)
696 697 698 699
                except Exception as e:
                    failed.append((u, e))
                else:
                    success.append(u)
700
            if self.status == "RUNNING":
701 702
                token = absolute_url(
                    VmRenewView.get_token_url(self, self.owner))
703 704 705
                queue = self.get_remote_queue_name("agent")
                agent_tasks.send_expiration.apply_async(
                    queue=queue, args=(self.vm_name, token))
706 707
        return True

708 709 710 711 712 713 714
    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
715 716
        return (self._is_suspend_expiring(threshold) or
                self._is_delete_expiring(threshold))
717 718 719

    def _is_suspend_expiring(self, threshold=0.1):
        interval = self.lease.suspend_interval
Bach Dániel committed
720 721 722
        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()))
723 724 725 726 727 728
            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
729 730 731
        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()))
732 733 734 735
            return limit > self.time_of_delete
        else:
            return False

736
    def get_renew_times(self, lease=None):
737 738
        """Returns new suspend and delete times if renew would be called.
        """
739 740
        if lease is None:
            lease = self.lease
741
        return (
742 743
            timezone.now() + lease.suspend_interval,
            timezone.now() + lease.delete_interval)
Dudás Ádám committed
744

745 746 747 748
    def select_node(self):
        """Returns the node the VM should be deployed or migrated to.
        """
        return scheduler.select_node(self, Node.objects.all())
749

750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
    def attach_disk(self, disk, timeout=15):
        queue_name = self.get_remote_queue_name('vm', 'fast')
        return vm_tasks.attach_disk.apply_async(
            args=[self.vm_name,
                  disk.get_vmdisk_desc()],
            queue=queue_name
        ).get(timeout=timeout)

    def detach_disk(self, disk, timeout=15):
        try:
            queue_name = self.get_remote_queue_name('vm', 'fast')
            return vm_tasks.detach_disk.apply_async(
                args=[self.vm_name,
                      disk.get_vmdisk_desc()],
                queue=queue_name
            ).get(timeout=timeout)
        except Exception as e:
            if e.libvirtError and "not found" in str(e):
                logger.debug("Disk %s was not found."
                             % disk.name)
            else:
                raise

    def attach_network(self, network, timeout=15):
        queue_name = self.get_remote_queue_name('vm', 'fast')
        return vm_tasks.attach_network.apply_async(
            args=[self.vm_name,
                  network.get_vmnetwork_desc()],
            queue=queue_name
        ).get(timeout=timeout)

    def detach_network(self, network, timeout=15):
        try:
            queue_name = self.get_remote_queue_name('vm', 'fast')
            return vm_tasks.detach_network.apply_async(
                args=[self.vm_name,
                      network.get_vmnetwork_desc()],
                queue=queue_name
            ).get(timeout=timeout)
        except Exception as e:
            if e.libvirtError and "not found" in str(e):
                logger.debug("Interface %s was not found."
                             % (network.__unicode__()))
            else:
                raise

Dudás Ádám committed
796 797
    def deploy_disks(self):
        """Deploy all associated disks.
798
        """
Dudás Ádám committed
799 800 801 802 803 804 805 806 807 808
        devnums = list(ascii_lowercase)  # a-z
        for disk in self.disks.all():
            # assign device numbers
            if disk.dev_num in devnums:
                devnums.remove(disk.dev_num)
            else:
                disk.dev_num = devnums.pop(0)
                disk.save()
            # deploy disk
            disk.deploy()
809

Dudás Ádám committed
810 811
    def destroy_disks(self):
        """Destroy all associated disks.
812
        """
Dudás Ádám committed
813 814
        for disk in self.disks.all():
            disk.destroy()
815

Dudás Ádám committed
816 817
    def deploy_net(self):
        """Deploy all associated network interfaces.
818
        """
Dudás Ádám committed
819 820
        for net in self.interface_set.all():
            net.deploy()
821

Dudás Ádám committed
822 823
    def destroy_net(self):
        """Destroy all associated network interfaces.
824
        """
Dudás Ádám committed
825 826
        for net in self.interface_set.all():
            net.destroy()
827

Dudás Ádám committed
828 829
    def shutdown_net(self):
        """Shutdown all associated network interfaces.
830
        """
Dudás Ádám committed
831 832
        for net in self.interface_set.all():
            net.shutdown()
833

Dudás Ádám committed
834
    def delete_vm(self, timeout=15):
835
        queue_name = self.get_remote_queue_name('vm', 'fast')
836
        try:
Dudás Ádám committed
837 838 839 840 841 842 843
            return vm_tasks.destroy.apply_async(args=[self.vm_name],
                                                queue=queue_name
                                                ).get(timeout=timeout)
        except Exception as e:
            if e.libvirtError and "Domain not found" in str(e):
                logger.debug("Domain %s was not found at %s"
                             % (self.vm_name, queue_name))
844
            else:
Dudás Ádám committed
845
                raise
846

Dudás Ádám committed
847
    def deploy_vm(self, timeout=15):
848
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
849
        return vm_tasks.deploy.apply_async(args=[self.get_vm_desc()],
850 851
                                           queue=queue_name
                                           ).get(timeout=timeout)
Guba Sándor committed
852

Dudás Ádám committed
853
    def migrate_vm(self, to_node, timeout=120):
854
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
855
        return vm_tasks.migrate.apply_async(args=[self.vm_name,
856 857
                                                  to_node.host.hostname,
                                                  True],
Dudás Ádám committed
858 859
                                            queue=queue_name
                                            ).get(timeout=timeout)
860

Dudás Ádám committed
861
    def reboot_vm(self, timeout=5):
862
        queue_name = self.get_remote_queue_name('vm', 'fast')
Dudás Ádám committed
863 864 865
        return vm_tasks.reboot.apply_async(args=[self.vm_name],
                                           queue=queue_name
                                           ).get(timeout=timeout)
866

Dudás Ádám committed
867
    def reset_vm(self, timeout=5):
868
        queue_name = self.get_remote_queue_name('vm', 'fast')
Dudás Ádám committed
869 870 871
        return vm_tasks.reset.apply_async(args=[self.vm_name],
                                          queue=queue_name
                                          ).get(timeout=timeout)
872

Dudás Ádám committed
873
    def resume_vm(self, timeout=15):
874
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
875 876 877
        return vm_tasks.resume.apply_async(args=[self.vm_name],
                                           queue=queue_name
                                           ).get(timeout=timeout)
878

879
    def shutdown_vm(self, task=None, step=5):
880
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
881 882
        logger.debug("RPC Shutdown at queue: %s, for vm: %s.", queue_name,
                     self.vm_name)
883 884 885 886 887 888
        remote = vm_tasks.shutdown.apply_async(kwargs={'name': self.vm_name},
                                               queue=queue_name)

        while True:
            try:
                return remote.get(timeout=step)
889
            except TimeoutError as e:
890
                if task is not None and task.is_aborted():
891
                    AbortableAsyncResult(remote.id).abort()
892 893
                    raise humanize_exception(ugettext_noop(
                        "Operation aborted by user."), e)
894

895
    def suspend_vm(self, timeout=230):
896
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
897 898
        return vm_tasks.sleep.apply_async(args=[self.vm_name,
                                                self.mem_dump['path']],
899 900
                                          queue=queue_name
                                          ).get(timeout=timeout)
Guba Sándor committed
901

Dudás Ádám committed
902
    def wake_up_vm(self, timeout=60):
903
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
904 905 906 907 908 909 910
        return vm_tasks.wake_up.apply_async(args=[self.vm_name,
                                                  self.mem_dump['path']],
                                            queue=queue_name
                                            ).get(timeout=timeout)

    def delete_mem_dump(self, timeout=15):
        queue_name = self.mem_dump['datastore'].get_remote_queue_name(
911 912
            'storage', 'fast')
        from storage.tasks.storage_tasks import delete_dump
Dudás Ádám committed
913 914 915 916 917 918
        delete_dump.apply_async(args=[self.mem_dump['path']],
                                queue=queue_name).get(timeout=timeout)

    def allocate_node(self):
        if self.node is None:
            self.node = self.select_node()
919 920
            self.save()

Dudás Ádám committed
921 922 923 924
    def yield_node(self):
        if self.node is not None:
            self.node = None
            self.save()
Guba Sándor committed
925

Dudás Ádám committed
926 927 928 929
    def allocate_vnc_port(self):
        if self.vnc_port is None:
            self.vnc_port = find_unused_vnc_port()
            self.save()
930

Dudás Ádám committed
931 932 933 934
    def yield_vnc_port(self):
        if self.vnc_port is not None:
            self.vnc_port = None
            self.save()
935 936 937

    def get_status_icon(self):
        return {
938 939 940 941 942 943 944 945
            'NOSTATE': 'fa-rocket',
            'RUNNING': 'fa-play',
            'STOPPED': 'fa-stop',
            'SUSPENDED': 'fa-pause',
            'ERROR': 'fa-warning',
            'PENDING': 'fa-rocket',
            'DESTROYED': 'fa-trash-o',
            'MIGRATING': 'fa-truck'}.get(self.status, 'fa-question')
946 947 948 949 950

    def get_activities(self, user=None):
        acts = (self.activity_log.filter(parent=None).
                order_by('-started').
                select_related('user').prefetch_related('children'))
951 952 953 954 955
        # Check latest activity for percentage
        for i in acts:
            if i.has_percentage():
                i.has_percent = True
                i.percentage = i.get_percentage()
956 957 958 959
        if user is not None:
            for i in acts:
                i.is_abortable_for_user = partial(i.is_abortable_for,
                                                  user=user)
960
        return acts
961

962
    def get_merged_activities(self, user=None):
963
        whitelist = ("create_disk", "download_disk")
964
        acts = self.get_activities(user)
965 966 967 968 969
        merged_acts = []
        latest = None

        for a in acts:
            if (latest == a.activity_code and
970
                    merged_acts[-1].result_data == a.result_data and
971
                    a.finished and merged_acts[-1].finished and
972
                    a.user == merged_acts[-1].user and
973 974
                    (merged_acts[-1].finished - a.finished).days < 7 and
                    not a.activity_code.endswith(whitelist)):
975 976 977 978 979 980 981 982
                merged_acts[-1].times += 1
            else:
                merged_acts.append(a)
                merged_acts[-1].times = 1
            latest = a.activity_code

        return merged_acts

983
    def get_screenshot(self, timeout=5):
Kálmán Viktor committed
984
        queue_name = self.get_remote_queue_name("vm", "fast")
985 986 987
        return vm_tasks.screenshot.apply_async(args=[self.vm_name],
                                               queue=queue_name
                                               ).get(timeout=timeout)
988 989 990 991

    def get_latest_activity_in_progress(self):
        try:
            return InstanceActivity.objects.filter(
992
                instance=self, succeeded=None, parent=None).latest("started")
993 994
        except InstanceActivity.DoesNotExist:
            return None