instance.py 31.6 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
13
from django.dispatch import Signal
14 15
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _
Dudás Ádám committed
16

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

Dudás Ádám committed
20
from acl.models import AclBase
21
from storage.models import Disk
22
from ..tasks import local_tasks, vm_tasks, agent_tasks
Őry Máté committed
23
from .activity import instance_activity
24
from .common import BaseResourceConfigModel, Lease
25 26
from .network import Interface
from .node import Node, Trait
27
from django.core.exceptions import PermissionDenied
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 81

    class Meta:
        abstract = True


class InstanceTemplate(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
    """
Őry Máté committed
97
    STATES = [('NEW', _('new')),        # template has just been created
98
              ('SAVING', _('saving')),  # changes are being saved
Őry Máté committed
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
              ('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.'))
116 117

    class Meta:
Őry Máté committed
118 119
        app_label = 'vm'
        db_table = 'vm_instancetemplate'
120
        ordering = ['name', ]
Őry Máté committed
121 122 123
        permissions = (
            ('create_template', _('Can create an instance template.')),
        )
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
        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':
140
            return 'win'
141
        else:
142
            return 'linux'
143 144


145
class Instance(AclBase, VirtualMachineDescModel, TimeStampedModel):
tarokkk committed
146

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

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

    def __unicode__(self):
229 230
        parts = [self.name, "(" + str(self.id) + ")"]
        return " ".join([s for s in parts if s != ""])
231

232 233 234 235 236
    def clean(self, *args, **kwargs):
        if self.time_of_delete is None:
            self.renew(which='delete')
        super(Instance, self).clean(*args, **kwargs)

237
    @classmethod
238
    def create_from_template(cls, template, owner, disks=None, networks=None,
Dudás Ádám committed
239
                             req_traits=None, tags=None, **kwargs):
240 241 242 243 244
        """Create a new instance based on an InstanceTemplate.

        Can also specify parameters as keyword arguments which should override
        template settings.
        """
245 246 247 248 249 250 251 252 253 254 255 256 257 258
        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.
        """
259
        disks = template.disks.all() if disks is None else disks
260

261 262 263
        networks = (template.interface_set.all() if networks is None
                    else networks)

264 265 266 267
        for network in networks:
            if not network.vlan.has_level(owner, 'user'):
                raise PermissionDenied()

Dudás Ádám committed
268 269 270
        req_traits = (template.req_traits.all() if req_traits is None
                      else req_traits)

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

273
        # prepare parameters
Dudás Ádám committed
274 275 276 277 278 279 280
        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

281 282 283 284 285
        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):
286
        # create instance and do additional setup
Dudás Ádám committed
287 288
        inst = cls(**params)

289
        # save instance
290
        inst.clean()
291
        inst.save()
292
        inst.set_level(inst.owner, 'owner')
Dudás Ádám committed
293

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

297
        for net in networks:
298 299
            i = Interface.create(instance=inst, vlan=net.vlan,
                                 owner=inst.owner, managed=net.managed)
300 301
            if i.host:
                i.host.enable_net()
302 303 304
                port, proto = ACCESS_PROTOCOLS[i.instance.access_method][1:3]
                # TODO fix this port fw
                i.host.add_port(proto, private=port)
305

Dudás Ádám committed
306
        inst.req_traits.add(*req_traits)
Dudás Ádám committed
307 308
        inst.tags.add(*tags)

309 310
        return inst

Őry Máté committed
311
    @permalink
312
    def get_absolute_url(self):
313
        return ('dashboard.views.detail', None, {'pk': self.id})
314 315

    @property
316 317 318 319 320 321 322 323 324
    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
325
    def mem_dump(self):
326
        """Return the path and datastore for the memory dump.
327 328 329

        It is always on the first hard drive storage named cloud-<id>.dump
        """
330 331 332
        datastore = self.disks.all()[0].datastore
        path = datastore.path + '/' + self.vm_name + '.dump'
        return {'datastore': datastore, 'path': path}
333 334

    @property
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
    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):
350 351
        """Primary IPv4 address of the instance.
        """
352 353 354 355
        return self.primary_host.ipv4 if self.primary_host else None

    @property
    def ipv6(self):
356 357
        """Primary IPv6 address of the instance.
        """
358 359 360 361
        return self.primary_host.ipv6 if self.primary_host else None

    @property
    def mac(self):
362 363
        """Primary MAC address of the instance.
        """
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
        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.
        """
386
        return self.activity_log.filter(finished__isnull=True).exists()
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401

    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.
        """
402
        if not self.interface_set.exclude(host=None):
403 404
            return _('None')
        proto = 'ipv6' if use_ipv6 else 'ipv4'
405 406
        return self.interface_set.exclude(host=None)[0].host.get_hostname(
            proto=proto)
407

408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
    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
            print proto
            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

426 427 428 429 430 431 432 433 434
    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'
435 436 437
            return ('%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
438 439 440
        except:
            return

tarokkk committed
441 442
    def get_vm_desc(self):
        return {
443
            'name': self.vm_name,
444
            'vcpu': self.num_cores,
445
            'memory': int(self.ram_size) * 1024,  # convert from MiB to KiB
Őry Máté committed
446
            'memory_max': int(self.max_ram_size) * 1024,  # convert MiB to KiB
447 448 449 450 451
            '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()],
452 453 454 455 456
            '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
457
                'port': self.vnc_port
458
            },
459
            'boot_token': signing.dumps(self.id, salt='activate'),
Guba Sándor committed
460
            'raw_data': "" if not self.raw_data else self.raw_data
461
        }
tarokkk committed
462

463 464 465 466
    def get_remote_queue_name(self, queue_id):
        """Get the remote worker queue name of this instance with the specified
           queue ID.
        """
467
        return self.node.get_remote_queue_name(queue_id) if self.node else None
468

Dudás Ádám committed
469 470 471 472 473 474 475 476 477 478 479
    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()

480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
    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()

497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
    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')

540
    def deploy(self, user=None, task_uuid=None):
Dudás Ádám committed
541 542 543 544 545 546 547 548 549 550 551
        """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
552
        """
553 554
        with instance_activity(code_suffix='deploy', instance=self,
                               task_uuid=task_uuid, user=user) as act:
555

556 557 558
            # Clear destroyed flag
            self.destroyed = None

559
            self.__schedule_vm(act)
tarokkk committed
560

561 562
            # Deploy virtual images
            with act.sub_activity('deploying_disks'):
563
                devnums = list(string.ascii_lowercase)  # a-z
564
                for disk in self.disks.all():
565 566 567 568 569 570 571
                    # 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
572
                    disk.deploy()
573

574
            self.__deploy_vm(act)
575

576 577 578
    def deploy_async(self, user=None):
        """Execute deploy asynchronously.
        """
579 580
        logger.debug('Calling async local_tasks.deploy(%s, %s)',
                     unicode(self), unicode(user))
581 582
        return local_tasks.deploy.apply_async(args=[self, user],
                                              queue="localhost.man")
583

584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 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
    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")

654
    def destroy(self, user=None, task_uuid=None):
Dudás Ádám committed
655 656 657 658 659 660 661 662 663 664 665
        """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
666
        """
667 668 669
        if self.destroyed:
            return  # already destroyed, nothing to do here

670 671 672
        with instance_activity(code_suffix='destroy', instance=self,
                               task_uuid=task_uuid, user=user) as act:

673
            if self.node:
674
                self.__destroy_vm(act)
675 676 677 678 679 680

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

681
            self.__cleanup_after_destroy_vm(act)
682

Dudás Ádám committed
683
            self.destroyed = timezone.now()
684
            self.save()
685 686

    def destroy_async(self, user=None):
Dudás Ádám committed
687
        """Execute destroy asynchronously.
688
        """
689 690
        return local_tasks.destroy.apply_async(args=[self, user],
                                               queue="localhost.man")
691 692 693 694

    def sleep(self, user=None, task_uuid=None):
        """Suspend virtual machine with memory dump.
        """
695 696
        with instance_activity(code_suffix='sleep', instance=self,
                               task_uuid=task_uuid, user=user):
697

698
            queue_name = self.get_remote_queue_name('vm')
699 700
            vm_tasks.sleep.apply_async(args=[self.vm_name,
                                             self.mem_dump['path']],
701
                                       queue=queue_name).get()
Guba Sándor committed
702

703
    def sleep_async(self, user=None):
Dudás Ádám committed
704
        """Execute sleep asynchronously.
705
        """
706 707
        return local_tasks.sleep.apply_async(args=[self, user],
                                             queue="localhost.man")
Guba Sándor committed
708

709
    def wake_up(self, user=None, task_uuid=None):
710 711
        with instance_activity(code_suffix='wake_up', instance=self,
                               task_uuid=task_uuid, user=user):
712

713 714 715
            queue_name = self.get_remote_queue_name('vm')
            vm_tasks.resume.apply_async(args=[self.vm_name, self.dump_mem],
                                        queue=queue_name).get()
716

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

723 724 725
    def shutdown(self, user=None, task_uuid=None):
        """Shutdown virtual machine with ACPI signal.
        """
726 727
        with instance_activity(code_suffix='shutdown', instance=self,
                               task_uuid=task_uuid, user=user):
728

729 730 731
            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
732

733 734
    def shutdown_async(self, user=None):
        """Execute shutdown asynchronously.
735
        """
736 737
        return local_tasks.shutdown.apply_async(args=[self, user],
                                                queue="localhost.man")
Guba Sándor committed
738

739 740 741
    def reset(self, user=None, task_uuid=None):
        """Reset virtual machine (reset button)
        """
742 743
        with instance_activity(code_suffix='reset', instance=self,
                               task_uuid=task_uuid, user=user):
744

745 746 747
            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
748

749 750
    def reset_async(self, user=None):
        """Execute reset asynchronously.
751
        """
752 753
        return local_tasks.restart.apply_async(args=[self, user],
                                               queue="localhost.man")
Guba Sándor committed
754

755
    def reboot(self, user=None, task_uuid=None):
Dudás Ádám committed
756
        """Reboot virtual machine with Ctrl+Alt+Del signal.
757
        """
758 759
        with instance_activity(code_suffix='reboot', instance=self,
                               task_uuid=task_uuid, user=user):
760

761 762 763
            queue_name = self.get_remote_queue_name('vm')
            vm_tasks.reboot.apply_async(args=[self.vm_name],
                                        queue=queue_name).get()
764

765
    def reboot_async(self, user=None):
766
        """Execute reboot asynchronously. """
767 768
        return local_tasks.reboot.apply_async(args=[self, user],
                                              queue="localhost.man")
769

770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
    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()

797 798 799 800 801 802 803 804 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
    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
830

831 832 833 834
    def state_changed(self, new_state):
        logger.debug('Instance %s state changed '
                     '(db: %s, new: %s)',
                     self, self.state, new_state)
835 836 837 838 839 840 841 842 843
        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)