instance.py 34.2 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 celery.exceptions import TimeoutError
19
from model_utils.models import TimeStampedModel
20
from taggit.managers import TaggableManager
21

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

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

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


42
def find_unused_vnc_port():
43
    used = set(Instance.objects.values_list('vnc_port', flat=True))
44 45 46 47 48 49 50
    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.")


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

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


58
class VirtualMachineDescModel(BaseResourceConfigModel):
59

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

    class Meta:
        abstract = True


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

84 85 86 87 88 89 90 91 92 93 94 95 96 97
    """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
    """
98 99 100 101 102
    ACL_LEVELS = (
        ('user', _('user')),          # see all details
        ('operator', _('operator')),
        ('owner', _('owner')),        # superuser, can delete, delegate perms
    )
Őry Máté committed
103
    STATES = [('NEW', _('new')),        # template has just been created
104
              ('SAVING', _('saving')),  # changes are being saved
Őry Máté committed
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
              ('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.'))
122 123

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


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

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

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

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

245 246 247 248 249 250 251 252 253 254 255 256
    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

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

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

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

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

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

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

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

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

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

309
        # prepare parameters
Dudás Ádám committed
310 311 312 313 314 315 316
        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

317 318 319 320 321
        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):
322
        # create instance and do additional setup
Dudás Ádám committed
323 324
        inst = cls(**params)

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

330 331
        def __on_commit(activity):
            activity.resultant_state = 'PENDING'
332

333 334 335 336
        with instance_activity(code_suffix='create', instance=inst,
                               on_commit=__on_commit, user=inst.owner):
            # create related entities
            inst.disks.add(*[disk.get_exclusive() for disk in disks])
337

338 339 340
            for net in networks:
                Interface.create(instance=inst, vlan=net.vlan,
                                 owner=inst.owner, managed=net.managed)
Dudás Ádám committed
341

342 343 344 345
            inst.req_traits.add(*req_traits)
            inst.tags.add(*tags)

            return inst
346

Őry Máté committed
347
    @permalink
348
    def get_absolute_url(self):
349
        return ('dashboard.views.detail', None, {'pk': self.id})
350 351

    @property
352 353 354 355 356 357 358 359 360
    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
361
    def mem_dump(self):
362
        """Return the path and datastore for the memory dump.
363 364 365

        It is always on the first hard drive storage named cloud-<id>.dump
        """
366 367 368
        datastore = self.disks.all()[0].datastore
        path = datastore.path + '/' + self.vm_name + '.dump'
        return {'datastore': datastore, 'path': path}
369 370

    @property
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
    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):
386 387
        """Primary IPv4 address of the instance.
        """
388 389 390 391
        return self.primary_host.ipv4 if self.primary_host else None

    @property
    def ipv6(self):
392 393
        """Primary IPv6 address of the instance.
        """
394 395 396 397
        return self.primary_host.ipv6 if self.primary_host else None

    @property
    def mac(self):
398 399
        """Primary MAC address of the instance.
        """
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
        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.
        """
422
        return self.activity_log.filter(finished__isnull=True).exists()
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437

    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.
        """
438
        if not self.interface_set.exclude(host=None):
439 440
            return _('None')
        proto = 'ipv6' if use_ipv6 else 'ipv4'
441 442
        return self.interface_set.exclude(host=None)[0].host.get_hostname(
            proto=proto)
443

444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
    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

461 462 463 464 465 466 467 468 469
    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'
470 471 472
            return ('%(proto)s:cloud:%(pw)s:%(host)s:%(port)d' %
                    {'port': port, 'proto': proto, 'pw': self.pw,
                     'host': host})
473 474 475
        except:
            return

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

498 499 500 501
    def get_remote_queue_name(self, queue_id):
        """Get the remote worker queue name of this instance with the specified
           queue ID.
        """
502
        return self.node.get_remote_queue_name(queue_id) if self.node else None
503

Dudás Ádám committed
504 505 506 507 508 509 510 511 512 513 514
    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()

515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
    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()

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 569 570 571 572 573 574
    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')

575
    def deploy(self, user=None, task_uuid=None):
Dudás Ádám committed
576 577 578 579 580 581 582 583 584 585 586
        """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
587
        """
588 589 590
        if self.destroyed:
            raise self.InstanceDestroyedError(self)

591 592
        def __on_commit(activity):
            activity.resultant_state = 'RUNNING'
593

594 595 596
        with instance_activity(code_suffix='deploy', instance=self,
                               on_commit=__on_commit, task_uuid=task_uuid,
                               user=user) as act:
597

598
            self.__schedule_vm(act)
tarokkk committed
599

600 601
            # Deploy virtual images
            with act.sub_activity('deploying_disks'):
602
                devnums = list(string.ascii_lowercase)  # a-z
603
                for disk in self.disks.all():
604 605 606 607 608 609 610
                    # 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
611
                    disk.deploy()
612

613
            self.__deploy_vm(act)
614

615 616 617
    def deploy_async(self, user=None):
        """Execute deploy asynchronously.
        """
618 619
        logger.debug('Calling async local_tasks.deploy(%s, %s)',
                     unicode(self), unicode(user))
620 621
        return local_tasks.deploy.apply_async(args=[self, user],
                                              queue="localhost.man")
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 684 685 686 687 688 689 690 691 692
    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")

693
    def destroy(self, user=None, task_uuid=None):
Dudás Ádám committed
694 695 696 697 698 699 700 701 702 703 704
        """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
705
        """
706 707 708
        if self.destroyed:
            return  # already destroyed, nothing to do here

709 710 711
        def __on_commit(activity):
            activity.resultant_state = 'DESTROYED'

712
        with instance_activity(code_suffix='destroy', instance=self,
713 714
                               on_commit=__on_commit, task_uuid=task_uuid,
                               user=user) as act:
715

716
            if self.node:
717
                self.__destroy_vm(act)
718 719 720 721 722 723

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

724
            self.__cleanup_after_destroy_vm(act)
725

Dudás Ádám committed
726
            self.destroyed = timezone.now()
727
            self.save()
728 729

    def destroy_async(self, user=None):
Dudás Ádám committed
730
        """Execute destroy asynchronously.
731
        """
732 733
        return local_tasks.destroy.apply_async(args=[self, user],
                                               queue="localhost.man")
734 735 736 737

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

741 742 743 744 745 746 747 748 749
        def __on_abort(activity, error):
            if isinstance(error, TimeoutError):
                activity.resultant_state = None
            else:
                activity.resultant_state = 'ERROR'

        def __on_commit(activity):
            activity.resultant_state = 'SUSPENDED'

750
        with instance_activity(code_suffix='sleep', instance=self,
751
                               on_abort=__on_abort, on_commit=__on_commit,
752
                               task_uuid=task_uuid, user=user):
753

754
            queue_name = self.get_remote_queue_name('vm')
755 756
            vm_tasks.sleep.apply_async(args=[self.vm_name,
                                             self.mem_dump['path']],
757
                                       queue=queue_name).get()
Guba Sándor committed
758

759
    def sleep_async(self, user=None):
Dudás Ádám committed
760
        """Execute sleep asynchronously.
761
        """
762 763
        return local_tasks.sleep.apply_async(args=[self, user],
                                             queue="localhost.man")
Guba Sándor committed
764

765
    def wake_up(self, user=None, task_uuid=None):
766 767 768
        if self.state not in ['SUSPENDED']:
            raise self.WrongStateError(self)

769 770 771 772 773 774
        def __on_abort(activity, error):
            activity.resultant_state = 'ERROR'

        def __on_commit(activity):
            activity.resultant_state = 'RUNNING'

775
        with instance_activity(code_suffix='wake_up', instance=self,
776
                               on_abort=__on_abort, on_commit=__on_commit,
777
                               task_uuid=task_uuid, user=user):
778

779 780 781
            queue_name = self.get_remote_queue_name('vm')
            vm_tasks.resume.apply_async(args=[self.vm_name, self.dump_mem],
                                        queue=queue_name).get()
782

783
    def wake_up_async(self, user=None):
Dudás Ádám committed
784
        """Execute wake_up asynchronously.
785
        """
786 787
        return local_tasks.wake_up.apply_async(args=[self, user],
                                               queue="localhost.man")
788

789 790 791
    def shutdown(self, user=None, task_uuid=None):
        """Shutdown virtual machine with ACPI signal.
        """
792 793 794 795 796 797 798 799 800
        def __on_abort(activity, error):
            if isinstance(error, TimeoutError):
                activity.resultant_state = None
            else:
                activity.resultant_state = 'ERROR'

        def __on_commit(activity):
            activity.resultant_state = 'STOPPED'

801
        with instance_activity(code_suffix='shutdown', instance=self,
802
                               on_abort=__on_abort, on_commit=__on_commit,
803
                               task_uuid=task_uuid, user=user):
804

805 806 807
            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
808

809 810
    def shutdown_async(self, user=None):
        """Execute shutdown asynchronously.
811
        """
812 813
        return local_tasks.shutdown.apply_async(args=[self, user],
                                                queue="localhost.man")
Guba Sándor committed
814

815 816 817
    def reset(self, user=None, task_uuid=None):
        """Reset virtual machine (reset button)
        """
818 819
        with instance_activity(code_suffix='reset', instance=self,
                               task_uuid=task_uuid, user=user):
820

821 822 823
            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
824

825 826
    def reset_async(self, user=None):
        """Execute reset asynchronously.
827
        """
828 829
        return local_tasks.restart.apply_async(args=[self, user],
                                               queue="localhost.man")
Guba Sándor committed
830

831
    def reboot(self, user=None, task_uuid=None):
Dudás Ádám committed
832
        """Reboot virtual machine with Ctrl+Alt+Del signal.
833
        """
834 835
        with instance_activity(code_suffix='reboot', instance=self,
                               task_uuid=task_uuid, user=user):
836

837 838 839
            queue_name = self.get_remote_queue_name('vm')
            vm_tasks.reboot.apply_async(args=[self.vm_name],
                                        queue=queue_name).get()
840

841
    def reboot_async(self, user=None):
842
        """Execute reboot asynchronously. """
843 844
        return local_tasks.reboot.apply_async(args=[self, user],
                                              queue="localhost.man")
845

846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872
    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()

873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905
    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
906

907 908 909 910
    def state_changed(self, new_state):
        logger.debug('Instance %s state changed '
                     '(db: %s, new: %s)',
                     self, self.state, new_state)
911 912 913 914 915 916 917 918 919
        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)