instance.py 33.2 KB
Newer Older
1
from __future__ import absolute_import, unicode_literals
2
from datetime import timedelta
3
from functools import partial
Őry Máté committed
4
from importlib import import_module
Dudás Ádám committed
5
from logging import getLogger
Dudás Ádám committed
6
from string import ascii_lowercase
7
from warnings import warn
8

9 10
from celery.exceptions import TimeoutError
from celery.contrib.abortable import AbortableAsyncResult
11
import django.conf
Őry Máté committed
12 13
from django.contrib.auth.models import User
from django.core import signing
Dudás Ádám committed
14
from django.core.exceptions import PermissionDenied
15 16 17
from django.db.models import (BooleanField, CharField, DateTimeField,
                              IntegerField, ForeignKey, Manager,
                              ManyToManyField, permalink, SET_NULL, TextField)
18
from django.dispatch import Signal
19 20
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _
Dudás Ádám committed
21

22 23
from model_utils import Choices
from model_utils.models import TimeStampedModel, StatusModel
24
from taggit.managers import TaggableManager
25

Dudás Ádám committed
26
from acl.models import AclBase
27
from common.operations import OperatedMixin
Dudás Ádám committed
28
from ..tasks import vm_tasks, agent_tasks
29 30
from .activity import (ActivityInProgressError, instance_activity,
                       InstanceActivity)
31
from .common import BaseResourceConfigModel, Lease
32 33
from .network import Interface
from .node import Node, Trait
34

35
logger = getLogger(__name__)
Őry Máté committed
36 37
pre_state_changed = Signal(providing_args=["new_state"])
post_state_changed = Signal(providing_args=["new_state"])
38
pwgen = User.objects.make_random_password
39
scheduler = import_module(name=django.conf.settings.VM_SCHEDULER)
Őry Máté committed
40

41
ACCESS_PROTOCOLS = django.conf.settings.VM_ACCESS_PROTOCOLS
Őry Máté committed
42 43
ACCESS_METHODS = [(key, name) for key, (name, port, transport)
                  in ACCESS_PROTOCOLS.iteritems()]
Bach Dániel committed
44
VNC_PORT_RANGE = (20000, 65536)  # inclusive start, exclusive end
45 46


47 48 49 50 51 52 53 54 55 56 57 58 59 60
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


61
def find_unused_vnc_port():
62 63 64 65 66
    port = find_unused_port(
        port_range=VNC_PORT_RANGE,
        used_ports=Instance.objects.values_list('vnc_port', flat=True))

    if port is None:
67
        raise Exception("No unused port could be found for VNC.")
68 69
    else:
        return port
70 71


72
class InstanceActiveManager(Manager):
Dudás Ádám committed
73

74 75
    def get_query_set(self):
        return super(InstanceActiveManager,
76
                     self).get_query_set().filter(destroyed_at=None)
77 78


79
class VirtualMachineDescModel(BaseResourceConfigModel):
80

81 82 83 84 85 86 87 88
    """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.'))
89
    lease = ForeignKey(Lease, help_text=_("Preferred expiration periods."))
90 91
    raw_data = TextField(verbose_name=_('raw_data'), blank=True, help_text=_(
        'Additional libvirt domain parameters in XML format.'))
Dudás Ádám committed
92 93 94 95 96
    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"))
97 98 99 100
    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
101
    tags = TaggableManager(blank=True, verbose_name=_("tags"))
102 103 104 105 106

    class Meta:
        abstract = True


107
class InstanceTemplate(AclBase, VirtualMachineDescModel, TimeStampedModel):
tarokkk committed
108

109 110
    """Virtual machine template.
    """
111 112 113 114 115
    ACL_LEVELS = (
        ('user', _('user')),          # see all details
        ('operator', _('operator')),
        ('owner', _('owner')),        # superuser, can delete, delegate perms
    )
Őry Máté committed
116 117 118 119 120 121
    name = CharField(max_length=100, unique=True,
                     verbose_name=_('name'),
                     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'),
122
                        on_delete=SET_NULL,
Őry Máté committed
123
                        help_text=_('Template which this one is derived of.'))
Bach Dániel committed
124
    disks = ManyToManyField('storage.Disk', verbose_name=_('disks'),
Őry Máté committed
125 126
                            related_name='template_set',
                            help_text=_('Disks which are to be mounted.'))
127
    owner = ForeignKey(User)
128 129

    class Meta:
Őry Máté committed
130 131
        app_label = 'vm'
        db_table = 'vm_instancetemplate'
132
        ordering = ('name', )
Őry Máté committed
133 134 135
        permissions = (
            ('create_template', _('Can create an instance template.')),
        )
136 137 138 139 140 141
        verbose_name = _('template')
        verbose_name_plural = _('templates')

    def __unicode__(self):
        return self.name

142
    @property
143
    def running_instances(self):
144
        """The number of running instances of the template.
145
        """
146
        return sum(1 for i in self.instance_set.all() if i.is_running)
147 148 149

    @property
    def os_type(self):
150
        """The type of the template's operating system.
151 152
        """
        if self.access_method == 'rdp':
153
            return 'windows'
154
        else:
155
            return 'linux'
156

157 158 159 160
    @property
    def is_ready(self):
        return all(disk.is_ready for disk in self.disks)

161 162 163 164 165 166
    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')

167 168 169 170
    @permalink
    def get_absolute_url(self):
        return ('dashboard.views.template-detail', None, {'pk': self.pk})

171

172
class Instance(AclBase, VirtualMachineDescModel, StatusModel, OperatedMixin,
173
               TimeStampedModel):
tarokkk committed
174

175 176
    """Virtual machine instance.
    """
177 178 179 180 181
    ACL_LEVELS = (
        ('user', _('user')),          # see all details
        ('operator', _('operator')),  # console, networking, change state
        ('owner', _('owner')),        # superuser, can delete, delegate perms
    )
182 183 184 185 186 187 188 189 190
    STATUS = Choices(
        ('NOSTATE', _('no state')),
        ('RUNNING', _('running')),
        ('STOPPED', _('stopped')),
        ('SUSPENDED', _('suspended')),
        ('ERROR', _('error')),
        ('PENDING', _('pending')),
        ('DESTROYED', _('destroyed')),
    )
Őry Máté committed
191
    name = CharField(blank=True, max_length=100, verbose_name=_('name'),
192
                     help_text=_("Human readable name of instance."))
Őry Máté committed
193 194
    description = TextField(blank=True, verbose_name=_('description'))
    template = ForeignKey(InstanceTemplate, blank=True, null=True,
195
                          related_name='instance_set', on_delete=SET_NULL,
196
                          help_text=_("Template the instance derives from."),
Őry Máté committed
197
                          verbose_name=_('template'))
198
    pw = CharField(help_text=_("Original password of the instance."),
Őry Máté committed
199 200 201
                   max_length=20, verbose_name=_('password'))
    time_of_suspend = DateTimeField(blank=True, default=None, null=True,
                                    verbose_name=_('time of suspend'),
202 203
                                    help_text=_("Proposed time of automatic "
                                                "suspension."))
Őry Máté committed
204 205
    time_of_delete = DateTimeField(blank=True, default=None, null=True,
                                   verbose_name=_('time of delete'),
206 207
                                   help_text=_("Proposed time of automatic "
                                               "deletion."))
Őry Máté committed
208
    active_since = DateTimeField(blank=True, null=True,
209 210
                                 help_text=_("Time stamp of successful "
                                             "boot report."),
Őry Máté committed
211 212 213
                                 verbose_name=_('active since'))
    node = ForeignKey(Node, blank=True, null=True,
                      related_name='instance_set',
214
                      help_text=_("Current hypervisor of this instance."),
Őry Máté committed
215
                      verbose_name=_('host node'))
Bach Dániel committed
216
    disks = ManyToManyField('storage.Disk', related_name='instance_set',
217
                            help_text=_("Set of mounted disks."),
Őry Máté committed
218
                            verbose_name=_('disks'))
219 220 221
    vnc_port = IntegerField(blank=True, default=None, null=True,
                            help_text=_("TCP port where VNC console listens."),
                            unique=True, verbose_name=_('vnc_port'))
Őry Máté committed
222
    owner = ForeignKey(User)
223 224 225
    destroyed_at = DateTimeField(blank=True, null=True,
                                 help_text=_("The virtual machine's time of "
                                             "destruction."))
226 227
    objects = Manager()
    active = InstanceActiveManager()
228 229

    class Meta:
Őry Máté committed
230 231
        app_label = 'vm'
        db_table = 'vm_instance'
232
        ordering = ('pk', )
233 234 235 236 237 238
        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.')),
            ('config_ports', _('Can configure port forwards.')),
        )
239 240 241
        verbose_name = _('instance')
        verbose_name_plural = _('instances')

242 243 244 245 246 247 248 249 250 251 252
    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

253 254 255 256 257 258
    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."
259
                           % instance.status)
260 261 262 263 264

            Exception.__init__(self, message)

            self.instance = instance

265
    def __unicode__(self):
266
        parts = (self.name, "(" + str(self.id) + ")")
267
        return " ".join(s for s in parts if s != "")
268

269
    @property
270 271 272 273
    def is_console_available(self):
        return self.is_running

    @property
274
    def is_running(self):
Guba Sándor committed
275 276
        """Check if VM is in running state.
        """
277
        return self.status == 'RUNNING'
278 279

    @property
280
    def state(self):
281 282 283 284 285 286 287 288 289 290 291 292
        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)
293
            self.save(update_fields=('status', ))
294 295 296

    def _compute_status(self):
        """Return the proper status of the instance based on activities.
297
        """
298
        # check special cases
299 300 301 302
        if self.activity_log.filter(activity_code__endswith='migrate',
                                    finished__isnull=True).exists():
            return 'MIGRATING'

303 304 305 306 307 308
        # <<< 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]
309
        try:
310
            act = acts[0]
311
        except IndexError:
312 313 314
            return 'NOSTATE'
        else:
            return act.resultant_state
315

Dudás Ádám committed
316 317
    @classmethod
    def create(cls, params, disks, networks, req_traits, tags):
Guba Sándor committed
318 319
        """ Create new Instance object.
        """
Dudás Ádám committed
320 321
        # create instance and do additional setup
        inst = cls(**params)
322

Dudás Ádám committed
323 324 325 326
        # save instance
        inst.full_clean()
        inst.save()
        inst.set_level(inst.owner, 'owner')
327

Dudás Ádám committed
328 329
        def __on_commit(activity):
            activity.resultant_state = 'PENDING'
330

Dudás Ádám committed
331 332 333 334 335 336 337 338 339 340 341 342 343 344
        with instance_activity(code_suffix='create', instance=inst,
                               on_commit=__on_commit, user=inst.owner) as act:
            # create related entities
            inst.disks.add(*[disk.get_exclusive() for disk in disks])

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

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

            return inst
345

346
    @classmethod
347
    def create_from_template(cls, template, owner, disks=None, networks=None,
Dudás Ádám committed
348
                             req_traits=None, tags=None, **kwargs):
349 350 351 352 353
        """Create a new instance based on an InstanceTemplate.

        Can also specify parameters as keyword arguments which should override
        template settings.
        """
354 355 356 357 358 359 360 361 362 363 364 365 366 367
        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.
        """
368
        disks = template.disks.all() if disks is None else disks
369

370 371 372 373 374 375 376
        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()

377 378 379
        networks = (template.interface_set.all() if networks is None
                    else networks)

380 381 382 383
        for network in networks:
            if not network.vlan.has_level(owner, 'user'):
                raise PermissionDenied()

Dudás Ádám committed
384 385 386
        req_traits = (template.req_traits.all() if req_traits is None
                      else req_traits)

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

389
        # prepare parameters
Dudás Ádám committed
390 391
        common_fields = ['name', 'description', 'num_cores', 'ram_size',
                         'max_ram_size', 'arch', 'priority', 'boot_menu',
392
                         'raw_data', 'lease', 'access_method', 'system']
Dudás Ádám committed
393 394 395
        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
396 397

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

400 401 402 403 404
        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]
405

Dudás Ádám committed
406 407 408 409
    def clean(self, *args, **kwargs):
        if self.time_of_delete is None:
            self._do_renew(which='delete')
        super(Instance, self).clean(*args, **kwargs)
410

Guba Sándor committed
411 412 413 414 415
    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
416 417 418 419 420 421 422 423
        # TODO cancel concurrent activity (if exists)
        act = InstanceActivity.create(code_suffix='manual_state_change',
                                      instance=self, user=user)
        act.finished = act.started
        act.result = reason
        act.resultant_state = new_state
        act.succeeded = True
        act.save()
Dudás Ádám committed
424

Dudás Ádám committed
425 426 427 428 429 430 431 432
    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:
433 434 435 436
            if new_state == 'STOPPED':
                self.vnc_port = None
                self.node = None
                self.save()
Dudás Ádám committed
437 438 439 440
            act.finished = act.started
            act.resultant_state = new_state
            act.succeeded = True
            act.save()
441

Őry Máté committed
442
    @permalink
443
    def get_absolute_url(self):
444
        return ('dashboard.views.detail', None, {'pk': self.id})
445 446

    @property
447 448 449 450 451 452 453 454 455
    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
456
    def mem_dump(self):
457
        """Return the path and datastore for the memory dump.
458 459 460

        It is always on the first hard drive storage named cloud-<id>.dump
        """
461 462 463 464 465 466 467
        try:
            datastore = self.disks.all()[0].datastore
        except:
            return None
        else:
            path = datastore.path + '/' + self.vm_name + '.dump'
            return {'datastore': datastore, 'path': path}
468 469

    @property
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
    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):
485 486
        """Primary IPv4 address of the instance.
        """
487 488 489 490
        return self.primary_host.ipv4 if self.primary_host else None

    @property
    def ipv6(self):
491 492
        """Primary IPv6 address of the instance.
        """
493 494 495 496
        return self.primary_host.ipv6 if self.primary_host else None

    @property
    def mac(self):
497 498
        """Primary MAC address of the instance.
        """
499 500 501 502 503 504 505 506 507 508 509
        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

510 511 512 513 514 515 516 517 518
    @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

519 520 521 522 523 524 525 526 527 528 529
    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.
        """
530
        return self.activity_log.filter(finished__isnull=True).exists()
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545

    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.
        """
546
        if not self.interface_set.exclude(host=None):
547 548
            return _('None')
        proto = 'ipv6' if use_ipv6 else 'ipv4'
549 550
        return self.interface_set.exclude(host=None)[0].host.get_hostname(
            proto=proto)
551

552
    def get_connect_command(self, use_ipv6=False):
Guba Sándor committed
553 554
        """Returns a formatted connect string.
        """
555 556 557 558 559 560 561 562 563
        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':
564
                return ('sshpass -p %(pw)s ssh -o StrictHostKeyChecking=no '
565 566 567 568 569 570
                        'cloud@%(host)s -p %(port)d') % {
                    'port': port, 'proto': proto, 'pw': self.pw,
                    'host': host}
        except:
            return

571 572 573 574 575 576 577 578 579
    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'
580 581 582
            return ('%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
583 584 585
        except:
            return

tarokkk committed
586
    def get_vm_desc(self):
Guba Sándor committed
587 588
        """Serialize Instance object to vmdriver.
        """
tarokkk committed
589
        return {
590
            'name': self.vm_name,
591
            'vcpu': self.num_cores,
592
            'memory': int(self.ram_size) * 1024,  # convert from MiB to KiB
Őry Máté committed
593
            'memory_max': int(self.max_ram_size) * 1024,  # convert MiB to KiB
594 595 596 597 598
            '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()],
599 600 601 602 603
            '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
604
                'port': self.vnc_port
605
            },
606
            'boot_token': signing.dumps(self.id, salt='activate'),
Guba Sándor committed
607
            'raw_data': "" if not self.raw_data else self.raw_data
608
        }
tarokkk committed
609

610 611 612 613
    def get_remote_queue_name(self, queue_id):
        """Get the remote worker queue name of this instance with the specified
           queue ID.
        """
614 615 616 617
        if self.node:
            return self.node.get_remote_queue_name(queue_id)
        else:
            raise Node.DoesNotExist()
618

619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
    def _is_notified_about_expiration(self):
        renews = self.activity_log.filter(activity_code__endswith='renew')
        cond = {'activity_code__endswith': 'notification_about_expiration'}
        if len(renews) > 0:
            cond['finished__gt'] = renews[0].started
        return self.activity_log.filter(**cond).exists()

    def notify_owners_about_expiration(self, again=False):
        """Notify owners about vm expiring soon if they aren't already.

        :param again: Notify already notified owners.
        """
        if not again and self._is_notified_about_expiration():
            return False
        success, failed = [], []

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

        with instance_activity('notification_about_expiration', instance=self,
                               on_commit=on_commit):
            from dashboard.views import VmRenewView
            level = self.get_level_object("owner")
            for u, ulevel in self.get_users_with_level(level__pk=level.pk):
                try:
                    token = VmRenewView.get_token_url(self, u)
                    u.profile.notify(
                        _('%s expiring soon') % unicode(self),
                        'dashboard/notifications/vm-expiring.html',
                        {'instance': self, 'token': token}, valid_until=min(
                            self.time_of_delete, self.time_of_suspend))
                except Exception as e:
                    failed.append((u, e))
                else:
                    success.append(u)
        return True

656 657 658 659 660 661 662
    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
663 664
        return (self._is_suspend_expiring(threshold) or
                self._is_delete_expiring(threshold))
665 666 667

    def _is_suspend_expiring(self, threshold=0.1):
        interval = self.lease.suspend_interval
Bach Dániel committed
668 669 670
        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()))
671 672 673 674 675 676
            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
677 678 679
        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()))
680 681 682 683
            return limit > self.time_of_delete
        else:
            return False

684 685 686 687 688 689 690
    def get_renew_times(self):
        """Returns new suspend and delete times if renew would be called.
        """
        return (
            timezone.now() + self.lease.suspend_interval,
            timezone.now() + self.lease.delete_interval)

691 692 693 694 695 696 697 698 699
    def _do_renew(self, which='both'):
        """Set expiration times to renewed values.
        """
        time_of_suspend, time_of_delete = self.get_renew_times()
        if which in ('suspend', 'both'):
            self.time_of_suspend = time_of_suspend
        if which in ('delete', 'both'):
            self.time_of_delete = time_of_delete

700
    def renew(self, which='both', base_activity=None, user=None):
Dudás Ádám committed
701 702
        """Renew virtual machine instance leases.
        """
703
        if base_activity is None:
704 705
            act_ctx = instance_activity(code_suffix='renew', instance=self,
                                        user=user)
706
        else:
707 708 709
            act_ctx = base_activity.sub_activity('renew')

        with act_ctx:
710 711
            if which not in ('suspend', 'delete', 'both'):
                raise ValueError('No such expiration type.')
712
            self._do_renew(which)
713
            self.save()
Dudás Ádám committed
714

715 716 717 718 719 720 721 722 723 724 725
    def change_password(self, user=None):
        """Generate new password for the vm

        :param self: The virtual machine.

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

        self.pw = pwgen()
        with instance_activity(code_suffix='change_password', instance=self,
                               user=user):
726
            queue = self.get_remote_queue_name("agent")
727 728 729 730 731
            agent_tasks.change_password.apply_async(queue=queue,
                                                    args=(self.vm_name,
                                                          self.pw))
        self.save()

732 733 734 735
    def select_node(self):
        """Returns the node the VM should be deployed or migrated to.
        """
        return scheduler.select_node(self, Node.objects.all())
736

Dudás Ádám committed
737 738
    def deploy_disks(self):
        """Deploy all associated disks.
739
        """
Dudás Ádám committed
740 741 742 743 744 745 746 747 748 749
        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()
750

Dudás Ádám committed
751 752
    def destroy_disks(self):
        """Destroy all associated disks.
753
        """
Dudás Ádám committed
754 755
        for disk in self.disks.all():
            disk.destroy()
756

Dudás Ádám committed
757 758
    def deploy_net(self):
        """Deploy all associated network interfaces.
759
        """
Dudás Ádám committed
760 761
        for net in self.interface_set.all():
            net.deploy()
762

Dudás Ádám committed
763 764
    def destroy_net(self):
        """Destroy all associated network interfaces.
765
        """
Dudás Ádám committed
766 767
        for net in self.interface_set.all():
            net.destroy()
768

Dudás Ádám committed
769 770
    def shutdown_net(self):
        """Shutdown all associated network interfaces.
771
        """
Dudás Ádám committed
772 773
        for net in self.interface_set.all():
            net.shutdown()
774

Dudás Ádám committed
775 776
    def delete_vm(self, timeout=15):
        queue_name = self.get_remote_queue_name('vm')
777
        try:
Dudás Ádám committed
778 779 780 781 782 783 784
            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))
785
            else:
Dudás Ádám committed
786
                raise
787

Dudás Ádám committed
788 789 790
    def deploy_vm(self, timeout=15):
        queue_name = self.get_remote_queue_name('vm')
        return vm_tasks.deploy.apply_async(args=[self.get_vm_desc()],
791 792
                                           queue=queue_name
                                           ).get(timeout=timeout)
793

Dudás Ádám committed
794 795 796 797 798 799
    def migrate_vm(self, to_node, timeout=120):
        queue_name = self.get_remote_queue_name('vm')
        return vm_tasks.migrate.apply_async(args=[self.vm_name,
                                                  to_node.host.hostname],
                                            queue=queue_name
                                            ).get(timeout=timeout)
800

Dudás Ádám committed
801 802 803 804 805
    def reboot_vm(self, timeout=5):
        queue_name = self.get_remote_queue_name('vm')
        return vm_tasks.reboot.apply_async(args=[self.vm_name],
                                           queue=queue_name
                                           ).get(timeout=timeout)
806

Dudás Ádám committed
807 808 809 810 811
    def reset_vm(self, timeout=5):
        queue_name = self.get_remote_queue_name('vm')
        return vm_tasks.reset.apply_async(args=[self.vm_name],
                                          queue=queue_name
                                          ).get(timeout=timeout)
812

Dudás Ádám committed
813 814 815 816 817
    def resume_vm(self, timeout=15):
        queue_name = self.get_remote_queue_name('vm')
        return vm_tasks.resume.apply_async(args=[self.vm_name],
                                           queue=queue_name
                                           ).get(timeout=timeout)
818

819
    def shutdown_vm(self, task=None, step=5):
Dudás Ádám committed
820 821 822
        queue_name = self.get_remote_queue_name('vm')
        logger.debug("RPC Shutdown at queue: %s, for vm: %s.", queue_name,
                     self.vm_name)
823 824 825 826 827 828 829 830
        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():
831
                    AbortableAsyncResult(remote.id).abort()
832
                    raise Exception("Shutdown aborted by user.")
833

Dudás Ádám committed
834 835 836 837
    def suspend_vm(self, timeout=60):
        queue_name = self.get_remote_queue_name('vm')
        return vm_tasks.sleep.apply_async(args=[self.vm_name,
                                                self.mem_dump['path']],
838 839
                                          queue=queue_name
                                          ).get(timeout=timeout)
Guba Sándor committed
840

Dudás Ádám committed
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
    def wake_up_vm(self, timeout=60):
        queue_name = self.get_remote_queue_name('vm')
        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()
858
            self.save()
859

Dudás Ádám committed
860 861 862 863
    def yield_node(self):
        if self.node is not None:
            self.node = None
            self.save()
Guba Sándor committed
864

Dudás Ádám committed
865 866 867 868
    def allocate_vnc_port(self):
        if self.vnc_port is None:
            self.vnc_port = find_unused_vnc_port()
            self.save()
869

Dudás Ádám committed
870 871 872 873
    def yield_vnc_port(self):
        if self.vnc_port is not None:
            self.vnc_port = None
            self.save()
874 875 876 877 878 879 880

    def get_status_icon(self):
        return {
            'NOSTATE': 'icon-rocket',
            'RUNNING': 'icon-play',
            'STOPPED': 'icon-stop',
            'SUSPENDED': 'icon-pause',
881
            'ERROR': 'icon-warning-sign',
882 883 884
            'PENDING': 'icon-rocket',
            'DESTROYED': 'icon-trash',
            'MIGRATING': 'icon-truck'}.get(self.status, 'icon-question-sign')
885 886 887 888 889

    def get_activities(self, user=None):
        acts = (self.activity_log.filter(parent=None).
                order_by('-started').
                select_related('user').prefetch_related('children'))
890 891 892 893
        if user is not None:
            for i in acts:
                i.is_abortable_for_user = partial(i.is_abortable_for,
                                                  user=user)
894
        return acts