instance.py 39.5 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.db import IntegrityError
36
from django.dispatch import Signal
37
from django.utils import timezone
38
from django.utils.translation import ugettext_lazy as _, ugettext_noop
Dudás Ádám committed
39

40 41
from model_utils import Choices
from model_utils.models import TimeStampedModel, StatusModel
42
from taggit.managers import TaggableManager
43

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

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

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


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


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

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


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

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


102
class VirtualMachineDescModel(BaseResourceConfigModel):
103

104 105 106 107 108 109 110 111
    """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
112 113
    lease = ForeignKey(Lease, help_text=_("Preferred expiration periods."),
                       verbose_name=_("Lease"))
114 115
    raw_data = TextField(verbose_name=_('raw_data'), blank=True, help_text=_(
        'Additional libvirt domain parameters in XML format.'))
Dudás Ádám committed
116 117 118 119 120
    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"))
121 122 123 124
    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
125
    tags = TaggableManager(blank=True, verbose_name=_("tags"))
126 127 128 129
    has_agent = BooleanField(verbose_name=_('has agent'), default=True,
                             help_text=_(
                                 'If the machine has agent installed, and '
                                 'the manager should wait for its start.'))
130 131 132 133 134

    class Meta:
        abstract = True


135
class InstanceTemplate(AclBase, VirtualMachineDescModel, TimeStampedModel):
tarokkk committed
136

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

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

    def __unicode__(self):
        return self.name

173
    @property
174
    def running_instances(self):
175
        """The number of running instances of the template.
176
        """
177
        return sum(1 for i in self.instance_set.all() if i.is_running)
178 179 180

    @property
    def os_type(self):
181
        """The type of the template's operating system.
182 183
        """
        if self.access_method == 'rdp':
184
            return 'windows'
185
        else:
186
            return 'linux'
187

188 189 190 191
    @property
    def is_ready(self):
        return all(disk.is_ready for disk in self.disks)

192 193 194 195 196 197
    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')

198 199 200 201
    @permalink
    def get_absolute_url(self):
        return ('dashboard.views.template-detail', None, {'pk': self.pk})

202 203 204
    def remove_disk(self, disk, **kwargs):
        self.disks.remove(disk)

205 206 207 208 209 210
    def destroy_disks(self):
        """Destroy all associated disks.
        """
        for disk in self.disks.all():
            disk.destroy()

211 212 213
    def get_running_instances(self):
        return Instance.active.filter(template=self, status="RUNNING")

214

215
class Instance(AclBase, VirtualMachineDescModel, StatusModel, OperatedMixin,
216
               TimeStampedModel):
tarokkk committed
217

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

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

286
    class InstanceError(HumanReadableException):
287

288 289 290 291 292
        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)
293

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

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

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

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

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

315
    @property
316 317 318 319
    def is_console_available(self):
        return self.is_running

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

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

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

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

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

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

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

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

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

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

417 418 419
        networks = (template.interface_set.all() if networks is None
                    else networks)

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

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

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

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

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

441 442 443 444 445
        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]
446

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

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

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

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

        It is always on the first hard drive storage named cloud-<id>.dump
        """
492 493
        try:
            datastore = self.disks.all()[0].datastore
494 495 496 497 498 499
        except IndexError:
            from storage.models import DataStore
            datastore = DataStore.objects.get()

        path = datastore.path + '/' + self.vm_name + '.dump'
        return {'datastore': datastore, 'path': path}
500 501

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

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

    @property
    def mac(self):
533 534
        """Primary MAC address of the instance.
        """
535 536 537
        return self.primary_host.mac if self.primary_host else None

    @property
538 539 540 541 542 543 544 545
    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
    @property
    def waiting(self):
        """Indicates whether the instance's waiting for an operation to finish.
        """
550
        return self.activity_log.filter(finished__isnull=True).exists()
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565

    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.
        """
566 567
        if not self.primary_host:
            return None
568
        proto = 'ipv6' if use_ipv6 else 'ipv4'
569
        return self.primary_host.get_hostname(proto=proto)
570

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

590 591 592 593 594 595 596
    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
597
            return ('circle:%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
598 599
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
600 601 602
        except:
            return

603 604 605 606 607 608 609
    @property
    def short_hostname(self):
        try:
            return self.primary_host.hostname
        except AttributeError:
            return self.vm_name

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

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

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

    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
653 654 655 656 657 658 659

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

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

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

        with instance_activity('notification_about_expiration', instance=self,
681 682
                               readable_name=ugettext_noop(
                                   "notify owner about expiration"),
683
                               on_commit=on_commit):
684
            from dashboard.views import VmRenewView, absolute_url
685 686 687 688 689
            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
690 691 692 693
                        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)
694 695 696 697
                except Exception as e:
                    failed.append((u, e))
                else:
                    success.append(u)
698
            if self.status == "RUNNING":
699 700
                token = absolute_url(
                    VmRenewView.get_token_url(self, self.owner))
701 702 703
                queue = self.get_remote_queue_name("agent")
                agent_tasks.send_expiration.apply_async(
                    queue=queue, args=(self.vm_name, token))
704 705
        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
    def select_node(self):
        """Returns the node the VM should be deployed or migrated to.
        """
        return scheduler.select_node(self, Node.objects.all())
747

748 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
    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

794
    def resize_disk_live(self, disk, size, timeout=15):
795
        queue_name = self.get_remote_queue_name('vm', 'slow')
796
        result = vm_tasks.resize_disk.apply_async(
797 798 799 800
            args=[self.vm_name, disk.path, size],
            queue=queue_name).get(timeout=timeout)
        disk.size = size
        disk.save()
801
        return result
802

Dudás Ádám committed
803 804
    def deploy_disks(self):
        """Deploy all associated disks.
805
        """
Dudás Ádám committed
806 807 808 809 810 811 812 813 814 815
        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()
816

Dudás Ádám committed
817 818
    def destroy_disks(self):
        """Destroy all associated disks.
819
        """
Dudás Ádám committed
820 821
        for disk in self.disks.all():
            disk.destroy()
822

Dudás Ádám committed
823 824
    def deploy_net(self):
        """Deploy all associated network interfaces.
825
        """
Dudás Ádám committed
826 827
        for net in self.interface_set.all():
            net.deploy()
828

Dudás Ádám committed
829 830
    def destroy_net(self):
        """Destroy all associated network interfaces.
831
        """
Dudás Ádám committed
832 833
        for net in self.interface_set.all():
            net.destroy()
834

Dudás Ádám committed
835 836
    def shutdown_net(self):
        """Shutdown all associated network interfaces.
837
        """
Dudás Ádám committed
838 839
        for net in self.interface_set.all():
            net.shutdown()
840

Dudás Ádám committed
841
    def delete_vm(self, timeout=15):
842
        queue_name = self.get_remote_queue_name('vm', 'fast')
843
        try:
Dudás Ádám committed
844 845 846 847 848 849 850
            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))
851
            else:
Dudás Ádám committed
852
                raise
853

Dudás Ádám committed
854
    def deploy_vm(self, timeout=15):
855
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
856
        return vm_tasks.deploy.apply_async(args=[self.get_vm_desc()],
857 858
                                           queue=queue_name
                                           ).get(timeout=timeout)
Guba Sándor committed
859

Dudás Ádám committed
860
    def migrate_vm(self, to_node, timeout=120):
861
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
862
        return vm_tasks.migrate.apply_async(args=[self.vm_name,
863 864
                                                  to_node.host.hostname,
                                                  True],
Dudás Ádám committed
865 866
                                            queue=queue_name
                                            ).get(timeout=timeout)
867

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

Dudás Ádám committed
874
    def reset_vm(self, timeout=5):
875
        queue_name = self.get_remote_queue_name('vm', 'fast')
Dudás Ádám committed
876 877 878
        return vm_tasks.reset.apply_async(args=[self.vm_name],
                                          queue=queue_name
                                          ).get(timeout=timeout)
879

Dudás Ádám committed
880
    def resume_vm(self, timeout=15):
881
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
882 883 884
        return vm_tasks.resume.apply_async(args=[self.vm_name],
                                           queue=queue_name
                                           ).get(timeout=timeout)
885

886
    def shutdown_vm(self, task=None, step=5):
887
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
888 889
        logger.debug("RPC Shutdown at queue: %s, for vm: %s.", queue_name,
                     self.vm_name)
890 891 892 893 894 895
        remote = vm_tasks.shutdown.apply_async(kwargs={'name': self.vm_name},
                                               queue=queue_name)

        while True:
            try:
                return remote.get(timeout=step)
896
            except TimeoutError as e:
897
                if task is not None and task.is_aborted():
898
                    AbortableAsyncResult(remote.id).abort()
899 900
                    raise humanize_exception(ugettext_noop(
                        "Operation aborted by user."), e)
901

902
    def suspend_vm(self, timeout=230):
903
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
904 905
        return vm_tasks.sleep.apply_async(args=[self.vm_name,
                                                self.mem_dump['path']],
906 907
                                          queue=queue_name
                                          ).get(timeout=timeout)
Guba Sándor committed
908

Dudás Ádám committed
909
    def wake_up_vm(self, timeout=60):
910
        queue_name = self.get_remote_queue_name('vm', 'slow')
Dudás Ádám committed
911 912 913 914 915 916 917
        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(
918 919
            'storage', 'fast')
        from storage.tasks.storage_tasks import delete_dump
Dudás Ádám committed
920 921 922
        delete_dump.apply_async(args=[self.mem_dump['path']],
                                queue=queue_name).get(timeout=timeout)

923 924 925 926 927 928 929
    def reallocate_node(self, activity):
        with activity.sub_activity(
                'scheduling',
                readable_name=ugettext_noop("schedule")) as sa:
            sa.result = node = self.select_node()
            return node

930 931 932 933 934 935 936 937
    def allocate_node(self, activity):
        if self.node is not None:
            return None

        with activity.sub_activity(
                'scheduling',
                readable_name=ugettext_noop("schedule")) as sa:
            sa.result = self.node = self.select_node()
938
            self.save()
939
            return self.node
940

Dudás Ádám committed
941 942 943 944
    def yield_node(self):
        if self.node is not None:
            self.node = None
            self.save()
Guba Sándor committed
945

Dudás Ádám committed
946 947
    def allocate_vnc_port(self):
        if self.vnc_port is None:
948 949 950 951 952 953 954 955 956 957
            while True:
                try:
                    self.vnc_port = find_unused_vnc_port()
                    self.save()
                except IntegrityError:
                    # Another thread took this port get another one
                    logger.debug("Port %s is in use.", self.vnc_port)
                    pass
                else:
                    break
958

Dudás Ádám committed
959 960 961 962
    def yield_vnc_port(self):
        if self.vnc_port is not None:
            self.vnc_port = None
            self.save()
963 964 965

    def get_status_icon(self):
        return {
966 967 968 969 970 971 972
            'NOSTATE': 'fa-rocket',
            'RUNNING': 'fa-play',
            'STOPPED': 'fa-stop',
            'SUSPENDED': 'fa-pause',
            'ERROR': 'fa-warning',
            'PENDING': 'fa-rocket',
            'DESTROYED': 'fa-trash-o',
973 974
            'MIGRATING': 'fa-truck migrating-icon'
        }.get(self.status, 'fa-question')
975 976 977 978 979

    def get_activities(self, user=None):
        acts = (self.activity_log.filter(parent=None).
                order_by('-started').
                select_related('user').prefetch_related('children'))
980 981 982 983 984
        # Check latest activity for percentage
        for i in acts:
            if i.has_percentage():
                i.has_percent = True
                i.percentage = i.get_percentage()
985 986 987 988
        if user is not None:
            for i in acts:
                i.is_abortable_for_user = partial(i.is_abortable_for,
                                                  user=user)
989
        return acts
990

991
    def get_merged_activities(self, user=None):
992
        whitelist = ("create_disk", "download_disk")
993
        acts = self.get_activities(user)
994 995 996 997 998
        merged_acts = []
        latest = None

        for a in acts:
            if (latest == a.activity_code and
999
                    merged_acts[-1].result_data == a.result_data and
1000
                    a.finished and merged_acts[-1].finished and
1001
                    a.user == merged_acts[-1].user and
1002 1003
                    (merged_acts[-1].finished - a.finished).days < 7 and
                    not a.activity_code.endswith(whitelist)):
1004 1005 1006 1007 1008 1009 1010 1011
                merged_acts[-1].times += 1
            else:
                merged_acts.append(a)
                merged_acts[-1].times = 1
            latest = a.activity_code

        return merged_acts

1012
    def get_screenshot(self, timeout=5):
Kálmán Viktor committed
1013
        queue_name = self.get_remote_queue_name("vm", "fast")
1014 1015 1016
        return vm_tasks.screenshot.apply_async(args=[self.vm_name],
                                               queue=queue_name
                                               ).get(timeout=timeout)
1017 1018 1019 1020

    def get_latest_activity_in_progress(self):
        try:
            return InstanceActivity.objects.filter(
1021
                instance=self, succeeded=None, parent=None).latest("started")
1022 1023
        except InstanceActivity.DoesNotExist:
            return None
1024 1025 1026 1027 1028

    def is_in_status_change(self):
        latest = self.get_latest_activity_in_progress()
        return (latest and latest.resultant_state is not None
                and self.status != latest.resultant_state)
1029 1030 1031 1032

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