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

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

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


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


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

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


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

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


99
class VirtualMachineDescModel(BaseResourceConfigModel):
100

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

    class Meta:
        abstract = True


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

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

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

    def __unicode__(self):
        return self.name

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

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

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

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

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

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

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

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
    active_since = DateTimeField(blank=True, null=True,
242 243
                                 help_text=_("Time stamp of successful "
                                             "boot report."),
Őry Máté committed
244 245 246
                                 verbose_name=_('active since'))
    node = ForeignKey(Node, blank=True, null=True,
                      related_name='instance_set',
247
                      help_text=_("Current hypervisor of this instance."),
Őry Máté committed
248
                      verbose_name=_('host node'))
Bach Dániel committed
249
    disks = ManyToManyField('storage.Disk', related_name='instance_set',
250
                            help_text=_("Set of mounted disks."),
Őry Máté committed
251
                            verbose_name=_('disks'))
252 253 254
    vnc_port = IntegerField(blank=True, default=None, null=True,
                            help_text=_("TCP port where VNC console listens."),
                            unique=True, verbose_name=_('vnc_port'))
255
    is_base = BooleanField(default=False)
Őry Máté committed
256
    owner = ForeignKey(User)
257 258 259
    destroyed_at = DateTimeField(blank=True, null=True,
                                 help_text=_("The virtual machine's time of "
                                             "destruction."))
260 261
    objects = Manager()
    active = InstanceActiveManager()
262 263

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

278 279 280 281 282 283 284 285 286 287 288
    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

289 290 291 292 293 294
    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."
295
                           % instance.status)
296 297 298 299 300

            Exception.__init__(self, message)

            self.instance = instance

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return inst
382

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

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

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

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

407 408 409 410 411 412 413
        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()

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

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

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

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

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

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

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

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

Guba Sándor committed
447 448 449 450 451
    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
452
        # TODO cancel concurrent activity (if exists)
453 454 455 456
        act = InstanceActivity.create(
            code_suffix='manual_state_change', instance=self, user=user,
            readable_name=create_readable(ugettext_noop(
                "force %(state)s state"), state=new_state))
Dudás Ádám committed
457 458 459 460 461
        act.finished = act.started
        act.result = reason
        act.resultant_state = new_state
        act.succeeded = True
        act.save()
Dudás Ádám committed
462

Dudás Ádám committed
463 464 465 466 467 468 469 470
    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:
471 472 473 474
            if new_state == 'STOPPED':
                self.vnc_port = None
                self.node = None
                self.save()
Dudás Ádám committed
475 476 477 478
            act.finished = act.started
            act.resultant_state = new_state
            act.succeeded = True
            act.save()
479

Őry Máté committed
480
    @permalink
481
    def get_absolute_url(self):
482
        return ('dashboard.views.detail', None, {'pk': self.id})
483 484

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

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

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

    @property
    def ipv6(self):
529 530
        """Primary IPv6 address of the instance.
        """
531 532 533 534
        return self.primary_host.ipv6 if self.primary_host else None

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

548 549 550 551 552 553 554 555 556
    @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

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

    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.
        """
584 585
        if not self.primary_host:
            return None
586
        proto = 'ipv6' if use_ipv6 else 'ipv4'
587
        return self.primary_host.get_hostname(proto=proto)
588

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

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

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

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

656
    def _is_notified_about_expiration(self):
657 658 659
        last_activity = self.activity_log.latest('pk')
        return (last_activity.activity_code ==
                'vm.Instance.notification_about_expiration')
660 661 662 663 664 665 666 667 668 669 670

    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):
671 672 673 674 675 676 677 678 679 680 681 682 683 684
            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)
685 686

        with instance_activity('notification_about_expiration', instance=self,
687 688
                               readable_name=ugettext_noop(
                                   "notify owner about expiration"),
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
                               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

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

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

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

743 744 745 746 747 748 749 750 751 752
    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,
753
                               readable_name=ugettext_noop("change password"),
754
                               user=user):
755
            queue = self.get_remote_queue_name("agent")
756 757 758 759 760
            agent_tasks.change_password.apply_async(queue=queue,
                                                    args=(self.vm_name,
                                                          self.pw))
        self.save()

761 762 763 764
    def select_node(self):
        """Returns the node the VM should be deployed or migrated to.
        """
        return scheduler.select_node(self, Node.objects.all())
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 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
    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
812 813
    def deploy_disks(self):
        """Deploy all associated disks.
814
        """
Dudás Ádám committed
815 816 817 818 819 820 821 822 823 824
        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()
825

Dudás Ádám committed
826 827
    def destroy_disks(self):
        """Destroy all associated disks.
828
        """
Dudás Ádám committed
829 830
        for disk in self.disks.all():
            disk.destroy()
831

Dudás Ádám committed
832 833
    def deploy_net(self):
        """Deploy all associated network interfaces.
834
        """
Dudás Ádám committed
835 836
        for net in self.interface_set.all():
            net.deploy()
837

Dudás Ádám committed
838 839
    def destroy_net(self):
        """Destroy all associated network interfaces.
840
        """
Dudás Ádám committed
841 842
        for net in self.interface_set.all():
            net.destroy()
843

Dudás Ádám committed
844 845
    def shutdown_net(self):
        """Shutdown all associated network interfaces.
846
        """
Dudás Ádám committed
847 848
        for net in self.interface_set.all():
            net.shutdown()
849

Dudás Ádám committed
850
    def delete_vm(self, timeout=15):
851
        queue_name = self.get_remote_queue_name('vm', 'fast')
852
        try:
Dudás Ádám committed
853 854 855 856 857 858 859
            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))
860
            else:
Dudás Ádám committed
861
                raise
862

Dudás Ádám committed
863
    def deploy_vm(self, timeout=15):
864
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
865
        return vm_tasks.deploy.apply_async(args=[self.get_vm_desc()],
866 867
                                           queue=queue_name
                                           ).get(timeout=timeout)
Guba Sándor committed
868

Dudás Ádám committed
869
    def migrate_vm(self, to_node, timeout=120):
870
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
871
        return vm_tasks.migrate.apply_async(args=[self.vm_name,
872 873
                                                  to_node.host.hostname,
                                                  True],
Dudás Ádám committed
874 875
                                            queue=queue_name
                                            ).get(timeout=timeout)
876

Dudás Ádám committed
877
    def reboot_vm(self, timeout=5):
878
        queue_name = self.get_remote_queue_name('vm', 'fast')
Dudás Ádám committed
879 880 881
        return vm_tasks.reboot.apply_async(args=[self.vm_name],
                                           queue=queue_name
                                           ).get(timeout=timeout)
882

Dudás Ádám committed
883
    def reset_vm(self, timeout=5):
884
        queue_name = self.get_remote_queue_name('vm', 'fast')
Dudás Ádám committed
885 886 887
        return vm_tasks.reset.apply_async(args=[self.vm_name],
                                          queue=queue_name
                                          ).get(timeout=timeout)
888

Dudás Ádám committed
889
    def resume_vm(self, timeout=15):
890
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
891 892 893
        return vm_tasks.resume.apply_async(args=[self.vm_name],
                                           queue=queue_name
                                           ).get(timeout=timeout)
894

895
    def shutdown_vm(self, task=None, step=5):
896
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
897 898
        logger.debug("RPC Shutdown at queue: %s, for vm: %s.", queue_name,
                     self.vm_name)
899 900 901 902 903 904 905 906
        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():
907
                    AbortableAsyncResult(remote.id).abort()
908
                    raise Exception("Shutdown aborted by user.")
909

910
    def suspend_vm(self, timeout=230):
911
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
912 913
        return vm_tasks.sleep.apply_async(args=[self.vm_name,
                                                self.mem_dump['path']],
914 915
                                          queue=queue_name
                                          ).get(timeout=timeout)
Guba Sándor committed
916

Dudás Ádám committed
917
    def wake_up_vm(self, timeout=60):
918
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
        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()
934 935
            self.save()

Dudás Ádám committed
936 937 938 939
    def yield_node(self):
        if self.node is not None:
            self.node = None
            self.save()
Guba Sándor committed
940

Dudás Ádám committed
941 942 943 944
    def allocate_vnc_port(self):
        if self.vnc_port is None:
            self.vnc_port = find_unused_vnc_port()
            self.save()
945

Dudás Ádám committed
946 947 948 949
    def yield_vnc_port(self):
        if self.vnc_port is not None:
            self.vnc_port = None
            self.save()
950 951 952

    def get_status_icon(self):
        return {
953 954 955 956 957 958 959 960
            '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')
961 962 963 964 965

    def get_activities(self, user=None):
        acts = (self.activity_log.filter(parent=None).
                order_by('-started').
                select_related('user').prefetch_related('children'))
966 967 968 969 970
        # Check latest activity for percentage
        for i in acts:
            if i.has_percentage():
                i.has_percent = True
                i.percentage = i.get_percentage()
971 972 973 974
        if user is not None:
            for i in acts:
                i.is_abortable_for_user = partial(i.is_abortable_for,
                                                  user=user)
975
        return acts
976

977
    def get_merged_activities(self, user=None):
978
        whitelist = ("create_disk", "download_disk")
979
        acts = self.get_activities(user)
980 981 982 983 984 985
        merged_acts = []
        latest = None

        for a in acts:
            if (latest == a.activity_code and
                    merged_acts[-1].result == a.result and
986
                    a.finished and merged_acts[-1].finished and
987
                    a.user == merged_acts[-1].user and
988 989
                    (merged_acts[-1].finished - a.finished).days < 7 and
                    not a.activity_code.endswith(whitelist)):
990 991 992 993 994 995 996 997
                merged_acts[-1].times += 1
            else:
                merged_acts.append(a)
                merged_acts[-1].times = 1
            latest = a.activity_code

        return merged_acts

998
    def get_screenshot(self, timeout=5):
Kálmán Viktor committed
999
        queue_name = self.get_remote_queue_name("vm", "fast")
1000 1001 1002
        return vm_tasks.screenshot.apply_async(args=[self.vm_name],
                                               queue=queue_name
                                               ).get(timeout=timeout)