instance.py 35 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 37
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _
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
from common.operations import OperatedMixin
Dudás Ádám committed
45
from ..tasks import vm_tasks, agent_tasks
46 47
from .activity import (ActivityInProgressError, instance_activity,
                       InstanceActivity)
48
from .common import BaseResourceConfigModel, Lease
49 50
from .network import Interface
from .node import Node, Trait
51

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

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


66 67 68 69 70 71 72 73 74 75 76 77 78 79
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


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

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


91
class InstanceActiveManager(Manager):
Dudás Ádám committed
92

93 94
    def get_query_set(self):
        return super(InstanceActiveManager,
95
                     self).get_query_set().filter(destroyed_at=None)
96 97


98
class VirtualMachineDescModel(BaseResourceConfigModel):
99

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

    class Meta:
        abstract = True


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

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

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

    def __unicode__(self):
        return self.name

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

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

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

184 185 186 187 188 189
    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')

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

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

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

203

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

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

    class Meta:
Őry Máté committed
263 264
        app_label = 'vm'
        db_table = 'vm_instance'
265
        ordering = ('pk', )
266 267 268 269
        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.')),
270
            ('create_vm', _('Can create a new VM.')),
271
            ('config_ports', _('Can configure port forwards.')),
Bach Dániel committed
272
            ('recover', _('Can recover a destroyed VM.')),
273
        )
274 275 276
        verbose_name = _('instance')
        verbose_name_plural = _('instances')

277 278 279 280 281 282 283 284 285 286 287
    class InstanceDestroyedError(Exception):

        def __init__(self, instance, message=None):
            if message is None:
                message = ("The instance (%s) has already been destroyed."
                           % instance)

            Exception.__init__(self, message)

            self.instance = instance

288 289 290 291 292 293
    class WrongStateError(Exception):

        def __init__(self, instance, message=None):
            if message is None:
                message = ("The instance's current state (%s) is "
                           "inappropriate for the invoked operation."
294
                           % instance.status)
295 296 297 298 299

            Exception.__init__(self, message)

            self.instance = instance

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

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

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

    @property
315
    def state(self):
316 317 318 319 320 321 322 323 324 325 326 327
        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)
328
            self.save(update_fields=('status', ))
329 330 331

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

338 339 340 341 342 343
        # <<< 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]
344
        try:
345
            act = acts[0]
346
        except IndexError:
347 348 349
            return 'NOSTATE'
        else:
            return act.resultant_state
350

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

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

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

Dudás Ádám committed
366 367 368 369 370 371 372 373 374 375 376 377 378 379
        with instance_activity(code_suffix='create', instance=inst,
                               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
380

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

        Can also specify parameters as keyword arguments which should override
        template settings.
        """
389 390 391 392 393 394 395 396 397 398 399 400 401 402
        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.
        """
403
        disks = template.disks.all() if disks is None else disks
404

405 406 407 408 409 410 411
        for disk in disks:
            if not disk.has_level(owner, 'user'):
                raise PermissionDenied()
            elif (disk.type == 'qcow2-snap'
                  and not disk.has_level(owner, 'owner')):
                raise PermissionDenied()

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

415 416 417 418
        for network in networks:
            if not network.vlan.has_level(owner, 'user'):
                raise PermissionDenied()

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

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

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

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

435 436 437 438 439
        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]
440

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

Guba Sándor committed
445 446 447 448 449
    def manual_state_change(self, new_state="NOSTATE", reason=None, user=None):
        """ Manually change state of an Instance.

        Can be used to recover VM after administrator fixed problems.
        """
Dudás Ádám committed
450 451 452 453 454 455 456 457
        # TODO cancel concurrent activity (if exists)
        act = InstanceActivity.create(code_suffix='manual_state_change',
                                      instance=self, user=user)
        act.finished = act.started
        act.result = reason
        act.resultant_state = new_state
        act.succeeded = True
        act.save()
Dudás Ádám committed
458

Dudás Ádám committed
459 460 461 462 463 464 465 466
    def vm_state_changed(self, new_state):
        # log state change
        try:
            act = InstanceActivity.create(code_suffix='vm_state_changed',
                                          instance=self)
        except ActivityInProgressError:
            pass  # discard state change if another activity is in progress.
        else:
467 468 469 470
            if new_state == 'STOPPED':
                self.vnc_port = None
                self.node = None
                self.save()
Dudás Ádám committed
471 472 473 474
            act.finished = act.started
            act.resultant_state = new_state
            act.succeeded = True
            act.save()
475

Őry Máté committed
476
    @permalink
477
    def get_absolute_url(self):
478
        return ('dashboard.views.detail', None, {'pk': self.id})
479 480

    @property
481 482 483 484 485 486 487 488 489
    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
490
    def mem_dump(self):
491
        """Return the path and datastore for the memory dump.
492 493 494

        It is always on the first hard drive storage named cloud-<id>.dump
        """
495 496 497 498 499 500 501
        try:
            datastore = self.disks.all()[0].datastore
        except:
            return None
        else:
            path = datastore.path + '/' + self.vm_name + '.dump'
            return {'datastore': datastore, 'path': path}
502 503

    @property
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
    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):
519 520
        """Primary IPv4 address of the instance.
        """
521 522 523 524
        return self.primary_host.ipv4 if self.primary_host else None

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

    @property
    def mac(self):
531 532
        """Primary MAC address of the instance.
        """
533 534 535 536 537 538 539 540 541 542 543
        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

544 545 546 547 548 549 550 551 552
    @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

553 554 555 556 557 558 559 560 561 562 563
    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.
        """
564
        return self.activity_log.filter(finished__isnull=True).exists()
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579

    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.
        """
580 581
        if not self.primary_host:
            return None
582
        proto = 'ipv6' if use_ipv6 else 'ipv4'
583
        return self.primary_host.get_hostname(proto=proto)
584

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

604 605 606 607 608 609 610 611 612
    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'
613 614 615
            return ('%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
616 617 618
        except:
            return

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

643
    def get_remote_queue_name(self, queue_id, priority=None):
644 645 646
        """Get the remote worker queue name of this instance with the specified
           queue ID.
        """
647
        if self.node:
648
            return self.node.get_remote_queue_name(queue_id, priority)
649 650
        else:
            raise Node.DoesNotExist()
651

652
    def _is_notified_about_expiration(self):
653 654 655
        last_activity = self.activity_log.latest('pk')
        return (last_activity.activity_code ==
                'vm.Instance.notification_about_expiration')
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686

    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.
        """
        if not again and self._is_notified_about_expiration():
            return False
        success, failed = [], []

        def on_commit(act):
            act.result = {'failed': failed, 'success': success}

        with instance_activity('notification_about_expiration', instance=self,
                               on_commit=on_commit):
            from dashboard.views import VmRenewView
            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(
                        _('%s expiring soon') % unicode(self),
                        'dashboard/notifications/vm-expiring.html',
                        {'instance': self, 'token': token}, valid_until=min(
                            self.time_of_delete, self.time_of_suspend))
                except Exception as e:
                    failed.append((u, e))
                else:
                    success.append(u)
        return True

687 688 689 690 691 692 693
    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
694 695
        return (self._is_suspend_expiring(threshold) or
                self._is_delete_expiring(threshold))
696 697 698

    def _is_suspend_expiring(self, threshold=0.1):
        interval = self.lease.suspend_interval
Bach Dániel committed
699 700 701
        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()))
702 703 704 705 706 707
            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
708 709 710
        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()))
711 712 713 714
            return limit > self.time_of_delete
        else:
            return False

715
    def get_renew_times(self, lease=None):
716 717
        """Returns new suspend and delete times if renew would be called.
        """
718 719
        if lease is None:
            lease = self.lease
720
        return (
721 722
            timezone.now() + lease.suspend_interval,
            timezone.now() + lease.delete_interval)
Dudás Ádám committed
723

724 725 726 727 728 729 730 731 732 733 734
    def change_password(self, user=None):
        """Generate new password for the vm

        :param self: The virtual machine.

        :param user: The user who's issuing the command.
        """

        self.pw = pwgen()
        with instance_activity(code_suffix='change_password', instance=self,
                               user=user):
735
            queue = self.get_remote_queue_name("agent")
736 737 738 739 740
            agent_tasks.change_password.apply_async(queue=queue,
                                                    args=(self.vm_name,
                                                          self.pw))
        self.save()

741 742 743 744
    def select_node(self):
        """Returns the node the VM should be deployed or migrated to.
        """
        return scheduler.select_node(self, Node.objects.all())
745

Dudás Ádám committed
746 747
    def deploy_disks(self):
        """Deploy all associated disks.
748
        """
Dudás Ádám committed
749 750 751 752 753 754 755 756 757 758
        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()
759

Dudás Ádám committed
760 761
    def destroy_disks(self):
        """Destroy all associated disks.
762
        """
Dudás Ádám committed
763 764
        for disk in self.disks.all():
            disk.destroy()
765

Dudás Ádám committed
766 767
    def deploy_net(self):
        """Deploy all associated network interfaces.
768
        """
Dudás Ádám committed
769 770
        for net in self.interface_set.all():
            net.deploy()
771

Dudás Ádám committed
772 773
    def destroy_net(self):
        """Destroy all associated network interfaces.
774
        """
Dudás Ádám committed
775 776
        for net in self.interface_set.all():
            net.destroy()
777

Dudás Ádám committed
778 779
    def shutdown_net(self):
        """Shutdown all associated network interfaces.
780
        """
Dudás Ádám committed
781 782
        for net in self.interface_set.all():
            net.shutdown()
783

Dudás Ádám committed
784
    def delete_vm(self, timeout=15):
785
        queue_name = self.get_remote_queue_name('vm', 'fast')
786
        try:
Dudás Ádám committed
787 788 789 790 791 792 793
            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))
794
            else:
Dudás Ádám committed
795
                raise
796

Dudás Ádám committed
797
    def deploy_vm(self, timeout=15):
798
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
799
        return vm_tasks.deploy.apply_async(args=[self.get_vm_desc()],
800 801
                                           queue=queue_name
                                           ).get(timeout=timeout)
Guba Sándor committed
802

Dudás Ádám committed
803
    def migrate_vm(self, to_node, timeout=120):
804
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
805
        return vm_tasks.migrate.apply_async(args=[self.vm_name,
806 807
                                                  to_node.host.hostname,
                                                  True],
Dudás Ádám committed
808 809
                                            queue=queue_name
                                            ).get(timeout=timeout)
810

Dudás Ádám committed
811
    def reboot_vm(self, timeout=5):
812
        queue_name = self.get_remote_queue_name('vm', 'fast')
Dudás Ádám committed
813 814 815
        return vm_tasks.reboot.apply_async(args=[self.vm_name],
                                           queue=queue_name
                                           ).get(timeout=timeout)
816

Dudás Ádám committed
817
    def reset_vm(self, timeout=5):
818
        queue_name = self.get_remote_queue_name('vm', 'fast')
Dudás Ádám committed
819 820 821
        return vm_tasks.reset.apply_async(args=[self.vm_name],
                                          queue=queue_name
                                          ).get(timeout=timeout)
822

Dudás Ádám committed
823
    def resume_vm(self, timeout=15):
824
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
825 826 827
        return vm_tasks.resume.apply_async(args=[self.vm_name],
                                           queue=queue_name
                                           ).get(timeout=timeout)
828

829
    def shutdown_vm(self, task=None, step=5):
830
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
831 832
        logger.debug("RPC Shutdown at queue: %s, for vm: %s.", queue_name,
                     self.vm_name)
833 834 835 836 837 838 839 840
        remote = vm_tasks.shutdown.apply_async(kwargs={'name': self.vm_name},
                                               queue=queue_name)

        while True:
            try:
                return remote.get(timeout=step)
            except TimeoutError:
                if task is not None and task.is_aborted():
841
                    AbortableAsyncResult(remote.id).abort()
842
                    raise Exception("Shutdown aborted by user.")
843

844
    def suspend_vm(self, timeout=230):
845
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
846 847
        return vm_tasks.sleep.apply_async(args=[self.vm_name,
                                                self.mem_dump['path']],
848 849
                                          queue=queue_name
                                          ).get(timeout=timeout)
Guba Sándor committed
850

Dudás Ádám committed
851
    def wake_up_vm(self, timeout=60):
852
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
        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(
            'storage')
        from storage.tasks.remote_tasks import delete_dump
        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()
868 869
            self.save()

Dudás Ádám committed
870 871 872 873
    def yield_node(self):
        if self.node is not None:
            self.node = None
            self.save()
Guba Sándor committed
874

Dudás Ádám committed
875 876 877 878
    def allocate_vnc_port(self):
        if self.vnc_port is None:
            self.vnc_port = find_unused_vnc_port()
            self.save()
879

Dudás Ádám committed
880 881 882 883
    def yield_vnc_port(self):
        if self.vnc_port is not None:
            self.vnc_port = None
            self.save()
884 885 886 887 888 889 890

    def get_status_icon(self):
        return {
            'NOSTATE': 'icon-rocket',
            'RUNNING': 'icon-play',
            'STOPPED': 'icon-stop',
            'SUSPENDED': 'icon-pause',
891
            'ERROR': 'icon-warning-sign',
892 893 894
            'PENDING': 'icon-rocket',
            'DESTROYED': 'icon-trash',
            'MIGRATING': 'icon-truck'}.get(self.status, 'icon-question-sign')
895 896 897 898 899

    def get_activities(self, user=None):
        acts = (self.activity_log.filter(parent=None).
                order_by('-started').
                select_related('user').prefetch_related('children'))
900 901 902 903 904
        # Check latest activity for percentage
        for i in acts:
            if i.has_percentage():
                i.has_percent = True
                i.percentage = i.get_percentage()
905 906 907 908
        if user is not None:
            for i in acts:
                i.is_abortable_for_user = partial(i.is_abortable_for,
                                                  user=user)
909
        return acts
910

911
    def get_merged_activities(self, user=None):
912
        whitelist = ("create_disk", "download_disk")
913
        acts = self.get_activities(user)
914 915 916 917 918 919
        merged_acts = []
        latest = None

        for a in acts:
            if (latest == a.activity_code and
                    merged_acts[-1].result == a.result and
920
                    a.finished and merged_acts[-1].finished and
921
                    a.user == merged_acts[-1].user and
922 923
                    (merged_acts[-1].finished - a.finished).days < 7 and
                    not a.activity_code.endswith(whitelist)):
924 925 926 927 928 929 930 931
                merged_acts[-1].times += 1
            else:
                merged_acts.append(a)
                merged_acts[-1].times = 1
            latest = a.activity_code

        return merged_acts

932
    def get_screenshot(self, timeout=5):
Kálmán Viktor committed
933
        queue_name = self.get_remote_queue_name("vm", "fast")
934 935 936
        return vm_tasks.screenshot.apply_async(args=[self.vm_name],
                                               queue=queue_name
                                               ).get(timeout=timeout)