instance.py 32.7 KB
Newer Older
1
from __future__ import absolute_import, unicode_literals
2
from datetime import timedelta
3
from logging import getLogger
Őry Máté committed
4
from importlib import import_module
5
import string
6

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

18
from model_utils.models import TimeStampedModel
19
from taggit.managers import TaggableManager
20

Dudás Ádám committed
21
from acl.models import AclBase
22
from storage.models import Disk
23
from ..tasks import local_tasks, vm_tasks, agent_tasks
Őry Máté committed
24
from .activity import instance_activity
25
from .common import BaseResourceConfigModel, Lease
26 27
from .network import Interface
from .node import Node, Trait
28

29
logger = getLogger(__name__)
Őry Máté committed
30 31
pre_state_changed = Signal(providing_args=["new_state"])
post_state_changed = Signal(providing_args=["new_state"])
32
pwgen = User.objects.make_random_password
33
scheduler = import_module(name=django.conf.settings.VM_SCHEDULER)
Őry Máté committed
34

35
ACCESS_PROTOCOLS = django.conf.settings.VM_ACCESS_PROTOCOLS
Őry Máté committed
36 37
ACCESS_METHODS = [(key, name) for key, (name, port, transport)
                  in ACCESS_PROTOCOLS.iteritems()]
38
VNC_PORT_RANGE = (2000, 65536)  # inclusive start, exclusive end
39 40


41
def find_unused_vnc_port():
42
    used = set(Instance.objects.values_list('vnc_port', flat=True))
43 44 45 46 47 48 49
    for p in xrange(*VNC_PORT_RANGE):
        if p not in used:
            return p
    else:
        raise Exception("No unused port could be found for VNC.")


50
class InstanceActiveManager(Manager):
Dudás Ádám committed
51

52 53 54 55 56
    def get_query_set(self):
        return super(InstanceActiveManager,
                     self).get_query_set().filter(destroyed=None)


57
class VirtualMachineDescModel(BaseResourceConfigModel):
58

59 60 61 62 63 64 65 66
    """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.'))
67
    lease = ForeignKey(Lease, help_text=_("Preferred expiration periods."))
68 69
    raw_data = TextField(verbose_name=_('raw_data'), blank=True, help_text=_(
        'Additional libvirt domain parameters in XML format.'))
Dudás Ádám committed
70 71 72 73 74
    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"))
Dudás Ádám committed
75
    tags = TaggableManager(blank=True, verbose_name=_("tags"))
76 77 78 79 80

    class Meta:
        abstract = True


81
class InstanceTemplate(AclBase, VirtualMachineDescModel, TimeStampedModel):
tarokkk committed
82

83 84 85 86 87 88 89 90 91 92 93 94 95 96
    """Virtual machine template.

    Every template has:
      * a name and a description
      * an optional parent template
      * state of the template
      * an OS name/description
      * a method of access to the system
      * default values of base resource configuration
      * list of attached images
      * set of interfaces
      * lease times (suspension & deletion)
      * time of creation and last modification
    """
97 98 99 100 101
    ACL_LEVELS = (
        ('user', _('user')),          # see all details
        ('operator', _('operator')),
        ('owner', _('owner')),        # superuser, can delete, delegate perms
    )
Őry Máté committed
102
    STATES = [('NEW', _('new')),        # template has just been created
103
              ('SAVING', _('saving')),  # changes are being saved
Őry Máté committed
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
              ('READY', _('ready'))]    # template is ready for instantiation
    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'),
                        help_text=_('Template which this one is derived of.'))
    system = TextField(verbose_name=_('operating system'),
                       blank=True,
                       help_text=(_('Name of operating system in '
                                    'format like "%s".') %
                                  'Ubuntu 12.04 LTS Desktop amd64'))
    state = CharField(max_length=10, choices=STATES, default='NEW')
    disks = ManyToManyField(Disk, verbose_name=_('disks'),
                            related_name='template_set',
                            help_text=_('Disks which are to be mounted.'))
121 122

    class Meta:
Őry Máté committed
123 124
        app_label = 'vm'
        db_table = 'vm_instancetemplate'
125
        ordering = ['name', ]
Őry Máté committed
126 127 128
        permissions = (
            ('create_template', _('Can create an instance template.')),
        )
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
        verbose_name = _('template')
        verbose_name_plural = _('templates')

    def __unicode__(self):
        return self.name

    def running_instances(self):
        """Returns the number of running instances of the template.
        """
        return self.instance_set.filter(state='RUNNING').count()

    @property
    def os_type(self):
        """Get the type of the template's operating system.
        """
        if self.access_method == 'rdp':
145
            return 'windows'
146
        else:
147
            return 'linux'
148 149


150
class Instance(AclBase, VirtualMachineDescModel, TimeStampedModel):
tarokkk committed
151

152 153 154 155 156 157 158 159 160 161 162
    """Virtual machine instance.

    Every instance has:
      * a name and a description
      * an optional parent template
      * associated share
      * a generated password for login authentication
      * time of deletion and time of suspension
      * lease times (suspension & deletion)
      * last boot timestamp
      * host node
163
      * current state (libvirt domain state)
164 165
      * time of creation and last modification
      * base resource configuration values
166
      * owner and privilege information
167 168 169 170 171 172 173 174 175
    """
    STATES = [('NOSTATE', _('nostate')),
              ('RUNNING', _('running')),
              ('BLOCKED', _('blocked')),
              ('PAUSED', _('paused')),
              ('SHUTDOWN', _('shutdown')),
              ('SHUTOFF', _('shutoff')),
              ('CRASHED', _('crashed')),
              ('PMSUSPENDED', _('pmsuspended'))]  # libvirt domain states
176 177 178 179 180
    ACL_LEVELS = (
        ('user', _('user')),          # see all details
        ('operator', _('operator')),  # console, networking, change state
        ('owner', _('owner')),        # superuser, can delete, delegate perms
    )
Őry Máté committed
181
    name = CharField(blank=True, max_length=100, verbose_name=_('name'),
182
                     help_text=_("Human readable name of instance."))
Őry Máté committed
183 184 185
    description = TextField(blank=True, verbose_name=_('description'))
    template = ForeignKey(InstanceTemplate, blank=True, null=True,
                          related_name='instance_set',
186
                          help_text=_("Template the instance derives from."),
Őry Máté committed
187
                          verbose_name=_('template'))
188
    pw = CharField(help_text=_("Original password of the instance."),
Őry Máté committed
189 190 191
                   max_length=20, verbose_name=_('password'))
    time_of_suspend = DateTimeField(blank=True, default=None, null=True,
                                    verbose_name=_('time of suspend'),
192 193
                                    help_text=_("Proposed time of automatic "
                                                "suspension."))
Őry Máté committed
194 195
    time_of_delete = DateTimeField(blank=True, default=None, null=True,
                                   verbose_name=_('time of delete'),
196 197
                                   help_text=_("Proposed time of automatic "
                                               "deletion."))
Őry Máté committed
198
    active_since = DateTimeField(blank=True, null=True,
199 200
                                 help_text=_("Time stamp of successful "
                                             "boot report."),
Őry Máté committed
201 202 203
                                 verbose_name=_('active since'))
    node = ForeignKey(Node, blank=True, null=True,
                      related_name='instance_set',
204
                      help_text=_("Current hypervisor of this instance."),
Őry Máté committed
205 206 207
                      verbose_name=_('host node'))
    state = CharField(choices=STATES, default='NOSTATE', max_length=20)
    disks = ManyToManyField(Disk, related_name='instance_set',
208
                            help_text=_("Set of mounted disks."),
Őry Máté committed
209
                            verbose_name=_('disks'))
210 211 212
    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
213
    owner = ForeignKey(User)
Dudás Ádám committed
214
    destroyed = DateTimeField(blank=True, null=True,
215 216
                              help_text=_("The virtual machine's time of "
                                          "destruction."))
217 218
    objects = Manager()
    active = InstanceActiveManager()
219 220

    class Meta:
Őry Máté committed
221 222
        app_label = 'vm'
        db_table = 'vm_instance'
223
        ordering = ['pk', ]
224 225 226 227 228 229
        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.')),
        )
230 231 232
        verbose_name = _('instance')
        verbose_name_plural = _('instances')

233 234 235 236 237 238 239 240 241 242 243
    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

244 245 246 247 248 249 250 251 252 253 254 255
    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."
                           % instance.state)

            Exception.__init__(self, message)

            self.instance = instance

256
    def __unicode__(self):
257 258
        parts = [self.name, "(" + str(self.id) + ")"]
        return " ".join([s for s in parts if s != ""])
259

260 261 262 263 264
    def clean(self, *args, **kwargs):
        if self.time_of_delete is None:
            self.renew(which='delete')
        super(Instance, self).clean(*args, **kwargs)

265
    @classmethod
266
    def create_from_template(cls, template, owner, disks=None, networks=None,
Dudás Ádám committed
267
                             req_traits=None, tags=None, **kwargs):
268 269 270 271 272
        """Create a new instance based on an InstanceTemplate.

        Can also specify parameters as keyword arguments which should override
        template settings.
        """
273 274 275 276 277 278 279 280 281 282 283 284 285 286
        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.
        """
287
        disks = template.disks.all() if disks is None else disks
288

289 290 291 292 293 294 295
        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()

296 297 298
        networks = (template.interface_set.all() if networks is None
                    else networks)

299 300 301 302
        for network in networks:
            if not network.vlan.has_level(owner, 'user'):
                raise PermissionDenied()

Dudás Ádám committed
303 304 305
        req_traits = (template.req_traits.all() if req_traits is None
                      else req_traits)

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

308
        # prepare parameters
Dudás Ádám committed
309 310 311 312 313 314 315
        common_fields = ['name', 'description', 'num_cores', 'ram_size',
                         'max_ram_size', 'arch', 'priority', 'boot_menu',
                         'raw_data', 'lease', 'access_method']
        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

316 317 318 319 320
        return [cls.__create_instance(params, disks, networks, req_traits,
                                      tags) for i in xrange(amount)]

    @classmethod
    def __create_instance(cls, params, disks, networks, req_traits, tags):
321
        # create instance and do additional setup
Dudás Ádám committed
322 323
        inst = cls(**params)

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

329
        # create related entities
Dudás Ádám committed
330
        inst.disks.add(*[disk.get_exclusive() for disk in disks])
331

332
        for net in networks:
333 334
            Interface.create(instance=inst, vlan=net.vlan,
                             owner=inst.owner, managed=net.managed)
335

Dudás Ádám committed
336
        inst.req_traits.add(*req_traits)
Dudás Ádám committed
337 338
        inst.tags.add(*tags)

339 340
        return inst

Őry Máté committed
341
    @permalink
342
    def get_absolute_url(self):
343
        return ('dashboard.views.detail', None, {'pk': self.id})
344 345

    @property
346 347 348 349 350 351 352 353 354
    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
355
    def mem_dump(self):
356
        """Return the path and datastore for the memory dump.
357 358 359

        It is always on the first hard drive storage named cloud-<id>.dump
        """
360 361 362
        datastore = self.disks.all()[0].datastore
        path = datastore.path + '/' + self.vm_name + '.dump'
        return {'datastore': datastore, 'path': path}
363 364

    @property
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
    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):
380 381
        """Primary IPv4 address of the instance.
        """
382 383 384 385
        return self.primary_host.ipv4 if self.primary_host else None

    @property
    def ipv6(self):
386 387
        """Primary IPv6 address of the instance.
        """
388 389 390 391
        return self.primary_host.ipv6 if self.primary_host else None

    @property
    def mac(self):
392 393
        """Primary MAC address of the instance.
        """
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
        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

    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.
        """
416
        return self.activity_log.filter(finished__isnull=True).exists()
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431

    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.
        """
432
        if not self.interface_set.exclude(host=None):
433 434
            return _('None')
        proto = 'ipv6' if use_ipv6 else 'ipv4'
435 436
        return self.interface_set.exclude(host=None)[0].host.get_hostname(
            proto=proto)
437

438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
    def get_connect_command(self, use_ipv6=False):
        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':
                return ('sshpass -p %(pw)s ssh -o StrictHostKeyChecking=n '
                        'cloud@%(host)s -p %(port)d') % {
                    'port': port, 'proto': proto, 'pw': self.pw,
                    'host': host}
        except:
            return

455 456 457 458 459 460 461 462 463
    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'
464 465 466
            return ('%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
467 468 469
        except:
            return

tarokkk committed
470 471
    def get_vm_desc(self):
        return {
472
            'name': self.vm_name,
473
            'vcpu': self.num_cores,
474
            'memory': int(self.ram_size) * 1024,  # convert from MiB to KiB
Őry Máté committed
475
            'memory_max': int(self.max_ram_size) * 1024,  # convert MiB to KiB
476 477 478 479 480
            '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()],
481 482 483 484 485
            '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
486
                'port': self.vnc_port
487
            },
488
            'boot_token': signing.dumps(self.id, salt='activate'),
Guba Sándor committed
489
            'raw_data': "" if not self.raw_data else self.raw_data
490
        }
tarokkk committed
491

492 493 494 495
    def get_remote_queue_name(self, queue_id):
        """Get the remote worker queue name of this instance with the specified
           queue ID.
        """
496
        return self.node.get_remote_queue_name(queue_id) if self.node else None
497

Dudás Ádám committed
498 499 500 501 502 503 504 505 506 507 508
    def renew(self, which='both'):
        """Renew virtual machine instance leases.
        """
        if which not in ['suspend', 'delete', 'both']:
            raise ValueError('No such expiration type.')
        if which in ['suspend', 'both']:
            self.time_of_suspend = timezone.now() + self.lease.suspend_interval
        if which in ['delete', 'both']:
            self.time_of_delete = timezone.now() + self.lease.delete_interval
        self.save()

509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
    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):
            queue = "%s.agent" % self.node.host.hostname
            agent_tasks.change_password.apply_async(queue=queue,
                                                    args=(self.vm_name,
                                                          self.pw))
        self.save()

526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
    def __schedule_vm(self, act):
        """Schedule the virtual machine.

        :param self: The virtual machine.

        :param act: Parent activity.
        """
        # Find unused port for VNC
        if self.vnc_port is None:
            self.vnc_port = find_unused_vnc_port()

        # Schedule
        if self.node is None:
            self.node = scheduler.select_node(self, Node.objects.all())

        self.save()

    def __deploy_vm(self, act):
        """Deploy the virtual machine.

        :param self: The virtual machine.

        :param act: Parent activity.
        """
        queue_name = self.get_remote_queue_name('vm')

        # Deploy VM on remote machine
        with act.sub_activity('deploying_vm'):
            vm_tasks.deploy.apply_async(args=[self.get_vm_desc()],
                                        queue=queue_name).get()

        # Estabilish network connection (vmdriver)
        with act.sub_activity('deploying_net'):
            for net in self.interface_set.all():
                net.deploy()

        # Resume vm
        with act.sub_activity('booting'):
            vm_tasks.resume.apply_async(args=[self.vm_name],
                                        queue=queue_name).get()

        self.renew('suspend')

569
    def deploy(self, user=None, task_uuid=None):
Dudás Ádám committed
570 571 572 573 574 575 576 577 578 579 580
        """Deploy new virtual machine with network

        :param self: The virtual machine to deploy.
        :type self: vm.models.Instance

        :param user: The user who's issuing the command.
        :type user: django.contrib.auth.models.User

        :param task_uuid: The task's UUID, if the command is being executed
                          asynchronously.
        :type task_uuid: str
581
        """
582 583 584
        if self.destroyed:
            raise self.InstanceDestroyedError(self)

585 586
        with instance_activity(code_suffix='deploy', instance=self,
                               task_uuid=task_uuid, user=user) as act:
587

588

589
            self.__schedule_vm(act)
tarokkk committed
590

591 592
            # Deploy virtual images
            with act.sub_activity('deploying_disks'):
593
                devnums = list(string.ascii_lowercase)  # a-z
594
                for disk in self.disks.all():
595 596 597 598 599 600 601
                    # 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
602
                    disk.deploy()
603

604
            self.__deploy_vm(act)
605

606 607 608
    def deploy_async(self, user=None):
        """Execute deploy asynchronously.
        """
609 610
        logger.debug('Calling async local_tasks.deploy(%s, %s)',
                     unicode(self), unicode(user))
611 612
        return local_tasks.deploy.apply_async(args=[self, user],
                                              queue="localhost.man")
613

614 615 616 617 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 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
    def __destroy_vm(self, act):
        """Destroy the virtual machine and its associated networks.

        :param self: The virtual machine.

        :param act: Parent activity.
        """
        # Destroy networks
        with act.sub_activity('destroying_net'):
            for net in self.interface_set.all():
                net.destroy()

        # Destroy virtual machine
        with act.sub_activity('destroying_vm'):
            queue_name = self.get_remote_queue_name('vm')
            vm_tasks.destroy.apply_async(args=[self.vm_name],
                                         queue=queue_name).get()

    def __cleanup_after_destroy_vm(self, act):
        """Clean up the virtual machine's data after destroy.

        :param self: The virtual machine.

        :param act: Parent activity.
        """
        # Delete mem. dump if exists
        queue_name = self.mem_dump['datastore'].get_remote_queue_name(
            'storage')
        try:
            from storage.tasks.remote_tasks import delete
            delete.apply_async(args=[self.mem_dump['path']],
                               queue=queue_name).get()
        except:
            pass

        # Clear node and VNC port association
        self.node = None
        self.vnc_port = None

    def redeploy(self, user=None, task_uuid=None):
        """Redeploy virtual machine with network

        :param self: The virtual machine to redeploy.

        :param user: The user who's issuing the command.
        :type user: django.contrib.auth.models.User

        :param task_uuid: The task's UUID, if the command is being executed
                          asynchronously.
        :type task_uuid: str
        """
        with instance_activity(code_suffix='redeploy', instance=self,
                               task_uuid=task_uuid, user=user) as act:
            # Destroy VM
            if self.node:
                self.__destroy_vm(act)

            self.__cleanup_after_destroy_vm(act)

            # Deploy VM
            self.__schedule_vm(act)

            self.__deploy_vm(act)

    def redeploy_async(self, user=None):
        """Execute redeploy asynchronously.
        """
        return local_tasks.redeploy.apply_async(args=[self, user],
                                                queue="localhost.man")

684
    def destroy(self, user=None, task_uuid=None):
Dudás Ádám committed
685 686 687 688 689 690 691 692 693 694 695
        """Remove virtual machine and its networks.

        :param self: The virtual machine to destroy.
        :type self: vm.models.Instance

        :param user: The user who's issuing the command.
        :type user: django.contrib.auth.models.User

        :param task_uuid: The task's UUID, if the command is being executed
                          asynchronously.
        :type task_uuid: str
696
        """
697 698 699
        if self.destroyed:
            return  # already destroyed, nothing to do here

700 701 702
        with instance_activity(code_suffix='destroy', instance=self,
                               task_uuid=task_uuid, user=user) as act:

703
            if self.node:
704
                self.__destroy_vm(act)
705 706 707 708 709 710

            # Destroy disks
            with act.sub_activity('destroying_disks'):
                for disk in self.disks.all():
                    disk.destroy()

711
            self.__cleanup_after_destroy_vm(act)
712

Dudás Ádám committed
713
            self.destroyed = timezone.now()
714
            self.save()
715 716

    def destroy_async(self, user=None):
Dudás Ádám committed
717
        """Execute destroy asynchronously.
718
        """
719 720
        return local_tasks.destroy.apply_async(args=[self, user],
                                               queue="localhost.man")
721 722 723 724

    def sleep(self, user=None, task_uuid=None):
        """Suspend virtual machine with memory dump.
        """
725 726 727
        if self.state not in ['RUNNING']:
            raise self.WrongStateError(self)

728 729
        with instance_activity(code_suffix='sleep', instance=self,
                               task_uuid=task_uuid, user=user):
730

731
            queue_name = self.get_remote_queue_name('vm')
732 733
            vm_tasks.sleep.apply_async(args=[self.vm_name,
                                             self.mem_dump['path']],
734
                                       queue=queue_name).get()
Guba Sándor committed
735

736
    def sleep_async(self, user=None):
Dudás Ádám committed
737
        """Execute sleep asynchronously.
738
        """
739 740
        return local_tasks.sleep.apply_async(args=[self, user],
                                             queue="localhost.man")
Guba Sándor committed
741

742
    def wake_up(self, user=None, task_uuid=None):
743 744 745
        if self.state not in ['SUSPENDED']:
            raise self.WrongStateError(self)

746 747
        with instance_activity(code_suffix='wake_up', instance=self,
                               task_uuid=task_uuid, user=user):
748

749 750 751
            queue_name = self.get_remote_queue_name('vm')
            vm_tasks.resume.apply_async(args=[self.vm_name, self.dump_mem],
                                        queue=queue_name).get()
752

753
    def wake_up_async(self, user=None):
Dudás Ádám committed
754
        """Execute wake_up asynchronously.
755
        """
756 757
        return local_tasks.wake_up.apply_async(args=[self, user],
                                               queue="localhost.man")
758

759 760 761
    def shutdown(self, user=None, task_uuid=None):
        """Shutdown virtual machine with ACPI signal.
        """
762 763
        with instance_activity(code_suffix='shutdown', instance=self,
                               task_uuid=task_uuid, user=user):
764

765 766 767
            queue_name = self.get_remote_queue_name('vm')
            vm_tasks.shutdown.apply_async(args=[self.vm_name],
                                          queue=queue_name).get()
Guba Sándor committed
768

769 770
    def shutdown_async(self, user=None):
        """Execute shutdown asynchronously.
771
        """
772 773
        return local_tasks.shutdown.apply_async(args=[self, user],
                                                queue="localhost.man")
Guba Sándor committed
774

775 776 777
    def reset(self, user=None, task_uuid=None):
        """Reset virtual machine (reset button)
        """
778 779
        with instance_activity(code_suffix='reset', instance=self,
                               task_uuid=task_uuid, user=user):
780

781 782 783
            queue_name = self.get_remote_queue_name('vm')
            vm_tasks.restart.apply_async(args=[self.vm_name],
                                         queue=queue_name).get()
Guba Sándor committed
784

785 786
    def reset_async(self, user=None):
        """Execute reset asynchronously.
787
        """
788 789
        return local_tasks.restart.apply_async(args=[self, user],
                                               queue="localhost.man")
Guba Sándor committed
790

791
    def reboot(self, user=None, task_uuid=None):
Dudás Ádám committed
792
        """Reboot virtual machine with Ctrl+Alt+Del signal.
793
        """
794 795
        with instance_activity(code_suffix='reboot', instance=self,
                               task_uuid=task_uuid, user=user):
796

797 798 799
            queue_name = self.get_remote_queue_name('vm')
            vm_tasks.reboot.apply_async(args=[self.vm_name],
                                        queue=queue_name).get()
800

801
    def reboot_async(self, user=None):
802
        """Execute reboot asynchronously. """
803 804
        return local_tasks.reboot.apply_async(args=[self, user],
                                              queue="localhost.man")
805

806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
    def migrate_async(self, to_node, user=None):
        """Execute migrate asynchronously. """
        return local_tasks.migrate.apply_async(args=[self, to_node, user],
                                               queue="localhost.man")

    def migrate(self, to_node, user=None, task_uuid=None):
        """Live migrate running vm to another node. """
        with instance_activity(code_suffix='migrate', instance=self,
                               task_uuid=task_uuid, user=user) as act:
            # Destroy networks
            with act.sub_activity('destroying_net'):
                for net in self.interface_set.all():
                    net.destroy()

            with act.sub_activity('migrate_vm'):
                queue_name = self.get_remote_queue_name('vm')
                vm_tasks.migrate.apply_async(args=[self.vm_name,
                                             to_node.host.hostname],
                                             queue=queue_name).get()
            # Refresh node information
            self.node = to_node
            self.save()
            # Estabilish network connection (vmdriver)
            with act.sub_activity('deploying_net'):
                for net in self.interface_set.all():
                    net.deploy()

833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
    def save_as_template(self, name, **kwargs):
        # prepare parameters
        kwargs.setdefault('name', name)
        kwargs.setdefault('description', self.description)
        kwargs.setdefault('parent', self.template)
        kwargs.setdefault('num_cores', self.num_cores)
        kwargs.setdefault('ram_size', self.ram_size)
        kwargs.setdefault('max_ram_size', self.max_ram_size)
        kwargs.setdefault('arch', self.arch)
        kwargs.setdefault('priority', self.priority)
        kwargs.setdefault('boot_menu', self.boot_menu)
        kwargs.setdefault('raw_data', self.raw_data)
        kwargs.setdefault('lease', self.lease)
        kwargs.setdefault('access_method', self.access_method)
        kwargs.setdefault('system', self.template.system
                          if self.template else None)
        # create template and do additional setup
        tmpl = InstanceTemplate(**kwargs)
        # save template
        tmpl.save()
        # create related entities
        for disk in self.disks.all():
            try:
                d = disk.save_as()
            except Disk.WrongDiskTypeError:
                d = disk

            tmpl.disks.add(d)

        for i in self.interface_set.all():
            i.save_as_template(tmpl)

        return tmpl
tarokkk committed
866

867 868 869 870
    def state_changed(self, new_state):
        logger.debug('Instance %s state changed '
                     '(db: %s, new: %s)',
                     self, self.state, new_state)
871 872 873 874 875 876 877 878 879
        try:
            pre_state_changed.send(sender=self, new_state=new_state)
        except Exception as e:
            logger.info('Instance %s state change ignored: %s',
                        unicode(self), unicode(e))
        else:
            self.state = new_state
            self.save()
            post_state_changed.send(sender=self, new_state=new_state)