instance.py 35.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
# Copyright 2014 Budapest University of Technology and Economics (BME IK)
#
# This file is part of CIRCLE Cloud.
#
# CIRCLE is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
#
# CIRCLE is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along
# with CIRCLE.  If not, see <http://www.gnu.org/licenses/>.

18
from __future__ import absolute_import, unicode_literals
19
from contextlib import contextmanager
20
from datetime import timedelta
21
from functools import partial
Őry Máté committed
22
from importlib import import_module
Dudás Ádám committed
23
from logging import getLogger
24
from warnings import warn
25

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

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

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

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

62
ACCESS_PROTOCOLS = django.conf.settings.VM_ACCESS_PROTOCOLS
Őry Máté committed
63 64
ACCESS_METHODS = [(key, name) for key, (name, port, transport)
                  in ACCESS_PROTOCOLS.iteritems()]
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
    port = find_unused_port(
83
        port_range=django.conf.settings.VNC_PORT_RANGE,
84 85 86
        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 VirtualMachineDescModel(BaseResourceConfigModel):
93

94 95 96 97 98 99 100 101
    """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
102 103
    lease = ForeignKey(Lease, help_text=_("Preferred expiration periods."),
                       verbose_name=_("Lease"))
104 105
    raw_data = TextField(verbose_name=_('raw_data'), blank=True, help_text=_(
        'Additional libvirt domain parameters in XML format.'))
Dudás Ádám committed
106 107 108 109 110
    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"))
111
    system = TextField(verbose_name=_('operating system'),
Bach Dániel committed
112 113
                       help_text=(_('Name of operating system in format like '
                                    '"Ubuntu 12.04 LTS Desktop amd64".')))
Dudás Ádám committed
114
    tags = TaggableManager(blank=True, verbose_name=_("tags"))
115 116 117 118
    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.'))
119 120 121 122 123

    class Meta:
        abstract = True


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

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

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

    def __unicode__(self):
        return self.name

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

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

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

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

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

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

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

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

203 204 205
    def get_user_instances(self, user):
        return Instance.active.filter(template=self, owner=user)

206 207 208 209
    @property
    def metric_prefix(self):
        return 'template.%d' % self.pk

210

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

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

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

282
    class InstanceError(HumanReadableException):
283

284 285 286 287 288
        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)
289

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

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

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

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

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

311
    @property
312 313 314 315
    def is_console_available(self):
        return self.is_running

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

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

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

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

Dudás Ádám committed
358 359
    @classmethod
    def create(cls, params, disks, networks, req_traits, tags):
Guba Sándor committed
360 361
        """ Create new Instance object.
        """
362 363 364 365 366 367

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

Dudás Ádám committed
368 369
        # create instance and do additional setup
        inst = cls(**params)
370

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

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

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

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

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

419 420 421
        networks = (template.interface_set.all() if networks is None
                    else networks)

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

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

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

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

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

445
    @classmethod
446
    def mass_create_for_users(cls, template, users, admin=None, operator=None, **kwargs):
447
        """
448 449
        Create and deploy an instance of a template for each user
        in a list of users. Returns the user IDs of missing users.
450 451
        """
        user_instances = []
452 453 454
        missing_users = []
        for user_id in users:
            try:
455
                user_instances.append(User.objects.get(profile__org_id=user_id))
456 457
            except User.DoesNotExist:
                missing_users.append(user_id)
458 459 460

        for user in user_instances:
            instance = cls.create_from_template(template, user, **kwargs)
461 462
            if admin:
                instance.set_level(User.objects.get(username=admin), 'owner')
463 464
            if operator:
                instance.set_level(User.objects.get(username=operator), 'operator')
465 466
            instance.deploy(user=user)

467
        return missing_users
468

Dudás Ádám committed
469
    def clean(self, *args, **kwargs):
470
        self.time_of_suspend, self.time_of_delete = self.get_renew_times()
Dudás Ádám committed
471
        super(Instance, self).clean(*args, **kwargs)
472

473 474 475
    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
476
        # log state change
477 478 479 480 481 482

        if new_node:
            msg = ugettext_noop("vm state changed to %(state)s on %(node)s")
        else:
            msg = ugettext_noop("vm state changed to %(state)s")

Dudás Ádám committed
483
        try:
484 485
            act = InstanceActivity.create(
                code_suffix='vm_state_changed',
486 487
                readable_name=create_readable(msg, state=new_state,
                                              node=new_node),
488
                instance=self)
Dudás Ádám committed
489 490 491
        except ActivityInProgressError:
            pass  # discard state change if another activity is in progress.
        else:
492 493 494
            if self.node != new_node:
                self.node = new_node
                self.save()
Dudás Ádám committed
495 496 497 498
            act.finished = act.started
            act.resultant_state = new_state
            act.succeeded = True
            act.save()
499

Őry Máté committed
500
    @permalink
501
    def get_absolute_url(self):
502
        return ('dashboard.views.detail', None, {'pk': self.id})
503 504

    @property
505 506 507 508 509 510 511 512 513
    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
514
    def mem_dump(self):
515
        """Return the path and datastore for the memory dump.
516 517 518

        It is always on the first hard drive storage named cloud-<id>.dump
        """
519 520
        try:
            datastore = self.disks.all()[0].datastore
521 522 523 524 525 526
        except IndexError:
            from storage.models import DataStore
            datastore = DataStore.objects.get()

        path = datastore.path + '/' + self.vm_name + '.dump'
        return {'datastore': datastore, 'path': path}
527 528

    @property
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
    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):
544 545
        """Primary IPv4 address of the instance.
        """
546 547 548 549 550
        # 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
551 552 553

    @property
    def ipv6(self):
554 555
        """Primary IPv6 address of the instance.
        """
556 557 558 559
        return self.primary_host.ipv6 if self.primary_host else None

    @property
    def mac(self):
560 561
        """Primary MAC address of the instance.
        """
562 563 564
        return self.primary_host.mac if self.primary_host else None

    @property
565 566 567 568 569 570 571 572
    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

573 574 575 576
    @property
    def waiting(self):
        """Indicates whether the instance's waiting for an operation to finish.
        """
577
        return self.activity_log.filter(finished__isnull=True).exists()
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592

    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.
        """
593 594
        if not self.primary_host:
            return None
595
        proto = 'ipv6' if use_ipv6 else 'ipv4'
596
        return self.primary_host.get_hostname(proto=proto)
597

598
    def get_connect_command(self, use_ipv6=False):
Guba Sándor committed
599 600
        """Returns a formatted connect string.
        """
601 602 603 604 605
        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':
606
                return 'rdesktop %(host)s:%(port)d -u cloud -p %(pw)s -f' % {
607 608 609
                    'port': port, 'proto': proto, 'pw': self.pw,
                    'host': host}
            elif proto == 'ssh':
610
                return ('sshpass -p %(pw)s ssh -o StrictHostKeyChecking=no '
611 612 613 614 615 616
                        'cloud@%(host)s -p %(port)d') % {
                    'port': port, 'proto': proto, 'pw': self.pw,
                    'host': host}
        except:
            return

617 618 619 620 621 622 623
    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
624
            return ('circle:%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
625 626
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
627 628 629
        except:
            return

630 631 632 633 634 635 636
    @property
    def short_hostname(self):
        try:
            return self.primary_host.hostname
        except AttributeError:
            return self.vm_name

tarokkk committed
637
    def get_vm_desc(self):
Guba Sándor committed
638 639
        """Serialize Instance object to vmdriver.
        """
tarokkk committed
640
        return {
641
            'name': self.vm_name,
642
            'vcpu': self.num_cores,
643
            'memory': int(self.ram_size) * 1024,  # convert from MiB to KiB
Őry Máté committed
644
            'memory_max': int(self.max_ram_size) * 1024,  # convert MiB to KiB
645 646 647 648 649
            '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()],
650 651 652 653 654
            '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
655
                'port': self.vnc_port
656
            },
657
            'boot_token': signing.dumps(self.id, salt='activate'),
Guba Sándor committed
658
            'raw_data': "" if not self.raw_data else self.raw_data
659
        }
tarokkk committed
660

661
    def get_remote_queue_name(self, queue_id, priority=None):
662 663 664
        """Get the remote worker queue name of this instance with the specified
           queue ID.
        """
665
        if self.node:
666
            return self.node.get_remote_queue_name(queue_id, priority)
667 668
        else:
            raise Node.DoesNotExist()
669

670
    def _is_notified_about_expiration(self):
671 672 673
        last_activity = self.activity_log.latest('pk')
        return (last_activity.activity_code ==
                'vm.Instance.notification_about_expiration')
674 675 676 677 678 679

    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
680 681 682 683 684 685 686

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

687 688 689 690 691
        if not again and self._is_notified_about_expiration():
            return False
        success, failed = [], []

        def on_commit(act):
692 693 694 695 696 697 698 699 700 701 702 703 704 705
            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)
706

707 708 709
        with self.activity('notification_about_expiration',
                           readable_name=ugettext_noop(
                               "notify owner about expiration"),
710
                           on_commit=on_commit, concurrency_check=False):
711
            from dashboard.views import VmRenewView, absolute_url
712 713 714 715 716
            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
717 718 719 720
                        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)
721 722 723 724
                except Exception as e:
                    failed.append((u, e))
                else:
                    success.append(u)
725
            if self.status == "RUNNING":
726 727
                token = absolute_url(
                    VmRenewView.get_token_url(self, self.owner))
728 729 730
                queue = self.get_remote_queue_name("agent")
                agent_tasks.send_expiration.apply_async(
                    queue=queue, args=(self.vm_name, token))
731 732
        return True

733 734 735 736 737 738 739
    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
740 741
        return (self._is_suspend_expiring(threshold) or
                self._is_delete_expiring(threshold))
742 743 744

    def _is_suspend_expiring(self, threshold=0.1):
        interval = self.lease.suspend_interval
745 746
        if (self.status != "SUSPENDED" and
                self.time_of_suspend is not None and interval is not None):
Bach Dániel committed
747 748
            limit = timezone.now() + timedelta(seconds=(
                threshold * self.lease.suspend_interval.total_seconds()))
749 750 751 752 753 754
            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
755 756 757
        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()))
758 759 760 761
            return limit > self.time_of_delete
        else:
            return False

762
    def get_renew_times(self, lease=None):
763 764
        """Returns new suspend and delete times if renew would be called.
        """
765 766
        if lease is None:
            lease = self.lease
767
        return (
768 769
            timezone.now() + lease.suspend_interval,
            timezone.now() + lease.delete_interval)
Dudás Ádám committed
770

771 772 773 774
    def select_node(self):
        """Returns the node the VM should be deployed or migrated to.
        """
        return scheduler.select_node(self, Node.objects.all())
775

Dudás Ádám committed
776 777
    def destroy_disks(self):
        """Destroy all associated disks.
778
        """
Dudás Ádám committed
779 780
        for disk in self.disks.all():
            disk.destroy()
781

Dudás Ádám committed
782 783
    def deploy_net(self):
        """Deploy all associated network interfaces.
784
        """
Dudás Ádám committed
785 786
        for net in self.interface_set.all():
            net.deploy()
787

Dudás Ádám committed
788 789
    def destroy_net(self):
        """Destroy all associated network interfaces.
790
        """
Dudás Ádám committed
791 792
        for net in self.interface_set.all():
            net.destroy()
793

Dudás Ádám committed
794 795
    def shutdown_net(self):
        """Shutdown all associated network interfaces.
796
        """
Dudás Ádám committed
797 798
        for net in self.interface_set.all():
            net.shutdown()
799

Dudás Ádám committed
800 801 802
    def allocate_node(self):
        if self.node is None:
            self.node = self.select_node()
803
            self.save()
804
            return self.node
805

Dudás Ádám committed
806 807 808 809
    def yield_node(self):
        if self.node is not None:
            self.node = None
            self.save()
Guba Sándor committed
810

Dudás Ádám committed
811 812
    def allocate_vnc_port(self):
        if self.vnc_port is None:
813 814 815 816 817 818 819 820 821 822
            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
823

Dudás Ádám committed
824 825 826 827
    def yield_vnc_port(self):
        if self.vnc_port is not None:
            self.vnc_port = None
            self.save()
828 829 830

    def get_status_icon(self):
        return {
831 832 833 834 835 836 837
            'NOSTATE': 'fa-rocket',
            'RUNNING': 'fa-play',
            'STOPPED': 'fa-stop',
            'SUSPENDED': 'fa-pause',
            'ERROR': 'fa-warning',
            'PENDING': 'fa-rocket',
            'DESTROYED': 'fa-trash-o',
838 839
            'MIGRATING': 'fa-truck migrating-icon'
        }.get(self.status, 'fa-question')
840 841 842 843 844

    def get_activities(self, user=None):
        acts = (self.activity_log.filter(parent=None).
                order_by('-started').
                select_related('user').prefetch_related('children'))
845 846 847 848 849
        # Check latest activity for percentage
        for i in acts:
            if i.has_percentage():
                i.has_percent = True
                i.percentage = i.get_percentage()
850 851 852 853
        if user is not None:
            for i in acts:
                i.is_abortable_for_user = partial(i.is_abortable_for,
                                                  user=user)
854
        return acts
855

856
    def get_merged_activities(self, user=None):
857 858 859
        whitelist = ("create_disk", "download_disk", "remove_disk",
                     "add_port", "remove_port",
                     "add_interface", "remove_interface")
860
        acts = self.get_activities(user)
861 862 863 864 865
        merged_acts = []
        latest = None

        for a in acts:
            if (latest == a.activity_code and
866
                    merged_acts[-1].result_data == a.result_data and
867
                    a.finished and merged_acts[-1].finished and
868
                    a.user == merged_acts[-1].user and
869 870
                    (merged_acts[-1].finished - a.finished).days < 7 and
                    not a.activity_code.endswith(whitelist)):
871 872 873 874 875 876 877 878
                merged_acts[-1].times += 1
            else:
                merged_acts.append(a)
                merged_acts[-1].times = 1
            latest = a.activity_code

        return merged_acts

879 880 881
    def get_latest_activity_in_progress(self):
        try:
            return InstanceActivity.objects.filter(
882
                instance=self, succeeded=None, parent=None).latest("started")
883 884
        except InstanceActivity.DoesNotExist:
            return None
885 886 887

    def is_in_status_change(self):
        latest = self.get_latest_activity_in_progress()
888 889
        return (latest and latest.resultant_state is not None and
                self.status != latest.resultant_state)
890 891 892 893

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

895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941

    class MonitorUnavailableException(Exception):
        """Exception for monitor_info()

            Indicates the unavailability of the monitoring server.
        """
        pass

    def monitor_info(self):
        metrics = ('cpu.percent', 'memory.usage')
        prefix = self.metric_prefix
        params = [('target', '%s.%s' % (prefix, metric))
                  for metric in metrics]
        params.append(('from', '-5min'))
        params.append(('format', 'json'))

        try:
            logger.info('%s %s', settings.GRAPHITE_URL, params)
            response = requests.get(settings.GRAPHITE_URL, params=params)

            retval = {}
            for target in response.json():
                # Example:
                # {"target": "circle.vm.{name}.cpu.usage",
                #  "datapoints": [[0.6, 1403045700], [0.5, 1403045760]
                try:
                    metric = target['target']
                    if metric.startswith(prefix):
                        metric = metric[len(prefix):]
                    else:
                        continue
                    value = target['datapoints'][-2][0]
                    retval[metric] = float(value)
                except (KeyError, IndexError, ValueError):
                    continue

            return retval
        except Exception:
            logger.exception('Monitor server unavailable: ')
            raise Instance.MonitorUnavailableException()

    def cpu_usage(self):
        return self.monitor_info().get('cpu.percent')

    def ram_usage(self):
        return self.monitor_info().get('memory.usage')

942 943 944 945 946 947 948 949 950 951 952 953 954
    @contextmanager
    def activity(self, code_suffix, readable_name, on_abort=None,
                 on_commit=None, task_uuid=None, user=None,
                 concurrency_check=True, resultant_state=None):
        """Create a transactional context for an instance activity.
        """
        if not readable_name:
            warn("Set readable_name", stacklevel=3)
        act = InstanceActivity.create(
            code_suffix=code_suffix, instance=self, task_uuid=task_uuid,
            user=user, concurrency_check=concurrency_check,
            readable_name=readable_name, resultant_state=resultant_state)
        return activitycontextimpl(act, on_abort=on_abort, on_commit=on_commit)