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

18
from __future__ import absolute_import, unicode_literals
Dudás Ádám committed
19
from logging import getLogger
20
from re import search
Őry Máté committed
21
from string import ascii_lowercase
Kálmán Viktor committed
22
from urlparse import urlsplit
Dudás Ádám committed
23

24
from django.core.exceptions import PermissionDenied
Dudás Ádám committed
25
from django.utils import timezone
26
from django.utils.translation import ugettext_lazy as _, ugettext_noop
Kálmán Viktor committed
27
from django.conf import settings
Dudás Ádám committed
28

29 30
from sizefield.utils import filesizeformat

Dudás Ádám committed
31
from celery.exceptions import TimeLimitExceeded
32

33 34 35
from common.models import (
    create_readable, humanize_exception, HumanReadableException
)
36
from common.operations import Operation, register_operation
Bach Dániel committed
37
from manager.scheduler import SchedulerError
38 39 40
from .tasks.local_tasks import (
    abortable_async_instance_operation, abortable_async_node_operation,
)
41
from .models import (
42
    Instance, InstanceActivity, InstanceTemplate, Interface, Node,
43
    NodeActivity, pwgen
44
)
45
from .tasks import agent_tasks, local_agent_tasks
Dudás Ádám committed
46

Kálmán Viktor committed
47 48
from dashboard.store_api import Store, NoStoreException

Dudás Ádám committed
49
logger = getLogger(__name__)
50 51


52
class InstanceOperation(Operation):
53
    acl_level = 'owner'
54
    async_operation = abortable_async_instance_operation
55
    host_cls = Instance
56
    concurrency_check = True
57 58
    accept_states = None
    deny_states = None
59
    resultant_state = None
Dudás Ádám committed
60

61
    def __init__(self, instance):
62
        super(InstanceOperation, self).__init__(subject=instance)
63 64 65
        self.instance = instance

    def check_precond(self):
66 67
        if self.instance.destroyed_at:
            raise self.instance.InstanceDestroyedError(self.instance)
68 69 70 71 72 73 74 75 76 77 78 79 80 81
        if self.accept_states:
            if self.instance.status not in self.accept_states:
                logger.debug("precond failed for %s: %s not in %s",
                             unicode(self.__class__),
                             unicode(self.instance.status),
                             unicode(self.accept_states))
                raise self.instance.WrongStateError(self.instance)
        if self.deny_states:
            if self.instance.status in self.deny_states:
                logger.debug("precond failed for %s: %s in %s",
                             unicode(self.__class__),
                             unicode(self.instance.status),
                             unicode(self.accept_states))
                raise self.instance.WrongStateError(self.instance)
82 83

    def check_auth(self, user):
84
        if not self.instance.has_level(user, self.acl_level):
85 86 87
            raise humanize_exception(ugettext_noop(
                "%(acl_level)s level is required for this operation."),
                PermissionDenied(), acl_level=self.acl_level)
88

89
        super(InstanceOperation, self).check_auth(user=user)
90

91 92
    def create_activity(self, parent, user, kwargs):
        name = self.get_activity_name(kwargs)
93 94 95 96 97 98 99 100 101 102
        if parent:
            if parent.instance != self.instance:
                raise ValueError("The instance associated with the specified "
                                 "parent activity does not match the instance "
                                 "bound to the operation.")
            if parent.user != user:
                raise ValueError("The user associated with the specified "
                                 "parent activity does not match the user "
                                 "provided as parameter.")

103
            return parent.create_sub(code_suffix=self.activity_code_suffix,
104 105
                                     readable_name=name,
                                     resultant_state=self.resultant_state)
106 107 108
        else:
            return InstanceActivity.create(
                code_suffix=self.activity_code_suffix, instance=self.instance,
109
                readable_name=name, user=user,
110 111
                concurrency_check=self.concurrency_check,
                resultant_state=self.resultant_state)
112

113 114 115 116 117
    def is_preferred(self):
        """If this is the recommended op in the current state of the instance.
        """
        return False

118

119
@register_operation
120 121 122 123 124 125
class AddInterfaceOperation(InstanceOperation):
    activity_code_suffix = 'add_interface'
    id = 'add_interface'
    name = _("add interface")
    description = _("Add a new network interface for the specified VLAN to "
                    "the VM.")
126
    required_perms = ()
127
    accept_states = ('STOPPED', 'PENDING', 'RUNNING')
128

129 130 131 132 133 134 135
    def rollback(self, net, activity):
        with activity.sub_activity(
            'destroying_net',
                readable_name=ugettext_noop("destroy network (rollback)")):
            net.destroy()
            net.delete()

136
    def _operation(self, activity, user, system, vlan, managed=None):
137
        if not vlan.has_level(user, 'user'):
138 139 140
            raise humanize_exception(ugettext_noop(
                "User acces to vlan %(vlan)s is required."),
                PermissionDenied(), vlan=vlan)
141 142 143 144 145 146 147
        if managed is None:
            managed = vlan.managed

        net = Interface.create(base_activity=activity, instance=self.instance,
                               managed=managed, owner=user, vlan=vlan)

        if self.instance.is_running:
148
            try:
149 150 151
                with activity.sub_activity(
                    'attach_network',
                        readable_name=ugettext_noop("attach network")):
152 153 154 155 156
                    self.instance.attach_network(net)
            except Exception as e:
                if hasattr(e, 'libvirtError'):
                    self.rollback(net, activity)
                raise
157
            net.deploy()
158
            local_agent_tasks.send_networking_commands(self.instance, activity)
159

160 161 162 163
    def get_activity_name(self, kwargs):
        return create_readable(ugettext_noop("add %(vlan)s interface"),
                               vlan=kwargs['vlan'])

164

165
@register_operation
166
class CreateDiskOperation(InstanceOperation):
167

168 169 170
    activity_code_suffix = 'create_disk'
    id = 'create_disk'
    name = _("create disk")
171
    description = _("Create and attach empty disk to the virtual machine.")
172
    required_perms = ('storage.create_empty_disk', )
173
    accept_states = ('STOPPED', 'PENDING', 'RUNNING')
174

175
    def _operation(self, user, size, activity, name=None):
Bach Dániel committed
176 177
        from storage.models import Disk

178 179 180
        if not name:
            name = "new disk"
        disk = Disk.create(size=size, name=name, type="qcow2-norm")
181
        disk.full_clean()
182 183 184 185
        devnums = list(ascii_lowercase)
        for d in self.instance.disks.all():
            devnums.remove(d.dev_num)
        disk.dev_num = devnums.pop(0)
186
        disk.save()
187 188
        self.instance.disks.add(disk)

189
        if self.instance.is_running:
190 191 192 193
            with activity.sub_activity(
                'deploying_disk',
                readable_name=ugettext_noop("deploying disk")
            ):
194
                disk.deploy()
195 196 197 198
            with activity.sub_activity(
                'attach_disk',
                readable_name=ugettext_noop("attach disk")
            ):
199 200
                self.instance.attach_disk(disk)

201
    def get_activity_name(self, kwargs):
202 203 204
        return create_readable(
            ugettext_noop("create disk %(name)s (%(size)s)"),
            size=filesizeformat(kwargs['size']), name=kwargs['name'])
205 206


207
@register_operation
208 209 210 211 212 213 214
class ResizeDiskOperation(InstanceOperation):

    activity_code_suffix = 'resize_disk'
    id = 'resize_disk'
    name = _("resize disk")
    description = _("Resize the virtual disk image. "
                    "Size must be greater value than the actual size.")
215
    required_perms = ('storage.resize_disk', )
216 217
    accept_states = ('RUNNING', )
    async_queue = "localhost.man.slow"
218 219

    def _operation(self, user, disk, size, activity):
220
        self.instance.resize_disk_live(disk, size)
221 222 223 224 225

    def get_activity_name(self, kwargs):
        return create_readable(
            ugettext_noop("resize disk %(name)s to %(size)s"),
            size=filesizeformat(kwargs['size']), name=kwargs['disk'].name)
226 227


228
@register_operation
229 230 231 232
class DownloadDiskOperation(InstanceOperation):
    activity_code_suffix = 'download_disk'
    id = 'download_disk'
    name = _("download disk")
233 234 235 236
    description = _("Download and attach disk image (ISO file) for the "
                    "virtual machine. Most operating systems do not detect a "
                    "new optical drive, so you may have to reboot the "
                    "machine.")
237
    abortable = True
238
    has_percentage = True
239
    required_perms = ('storage.download_disk', )
240
    accept_states = ('STOPPED', 'PENDING', 'RUNNING')
241
    async_queue = "localhost.man.slow"
242

243 244
    def _operation(self, user, url, task, activity, name=None):
        activity.result = url
Bach Dániel committed
245 246
        from storage.models import Disk

247
        disk = Disk.download(url=url, name=name, task=task)
248 249 250 251
        devnums = list(ascii_lowercase)
        for d in self.instance.disks.all():
            devnums.remove(d.dev_num)
        disk.dev_num = devnums.pop(0)
252
        disk.full_clean()
253
        disk.save()
254
        self.instance.disks.add(disk)
255 256
        activity.readable_name = create_readable(
            ugettext_noop("download %(name)s"), name=disk.name)
257

Őry Máté committed
258
        # TODO iso (cd) hot-plug is not supported by kvm/guests
259
        if self.instance.is_running and disk.type not in ["iso"]:
260 261 262 263
            with activity.sub_activity(
                'attach_disk',
                readable_name=ugettext_noop("attach disk")
            ):
264 265
                self.instance.attach_disk(disk)

266

267
@register_operation
268
class DeployOperation(InstanceOperation):
Dudás Ádám committed
269 270 271
    activity_code_suffix = 'deploy'
    id = 'deploy'
    name = _("deploy")
272 273
    description = _("Deploy and start the virtual machine (including storage "
                    "and network configuration).")
274
    required_perms = ()
275
    deny_states = ('SUSPENDED', 'RUNNING')
276
    resultant_state = 'RUNNING'
Dudás Ádám committed
277

278 279
    def is_preferred(self):
        return self.instance.status in (self.instance.STATUS.STOPPED,
280
                                        self.instance.STATUS.PENDING,
281 282
                                        self.instance.STATUS.ERROR)

283 284 285
    def on_abort(self, activity, error):
        activity.resultant_state = 'STOPPED'

Dudás Ádám committed
286 287
    def on_commit(self, activity):
        activity.resultant_state = 'RUNNING'
288
        activity.result = create_readable(
Guba Sándor committed
289
            ugettext_noop("virtual machine successfully "
290 291
                          "deployed to node: %(node)s"),
            node=self.instance.node)
Dudás Ádám committed
292

293
    def _operation(self, activity, timeout=15):
Dudás Ádám committed
294 295
        # Allocate VNC port and host node
        self.instance.allocate_vnc_port()
296
        self.instance.allocate_node(activity)
Dudás Ádám committed
297 298

        # Deploy virtual images
299 300 301
        with activity.sub_activity(
            'deploying_disks', readable_name=ugettext_noop(
                "deploy disks")):
Dudás Ádám committed
302 303 304
            self.instance.deploy_disks()

        # Deploy VM on remote machine
305
        if self.instance.state not in ['PAUSED']:
Guba Sándor committed
306 307 308
            rn = create_readable(ugettext_noop("deploy virtual machine"),
                                 ugettext_noop("deploy vm to %(node)s"),
                                 node=self.instance.node)
309
            with activity.sub_activity(
Guba Sándor committed
310
                    'deploying_vm', readable_name=rn) as deploy_act:
311
                deploy_act.result = self.instance.deploy_vm(timeout=timeout)
Dudás Ádám committed
312 313

        # Establish network connection (vmdriver)
314 315 316
        with activity.sub_activity(
            'deploying_net', readable_name=ugettext_noop(
                "deploy network")):
Dudás Ádám committed
317 318
            self.instance.deploy_net()

319 320 321 322 323
        try:
            self.instance.renew(parent_activity=activity)
        except:
            pass

Dudás Ádám committed
324
        # Resume vm
325 326 327
        with activity.sub_activity(
            'booting', readable_name=ugettext_noop(
                "boot virtual machine")):
Dudás Ádám committed
328
            self.instance.resume_vm(timeout=timeout)
Dudás Ádám committed
329

330 331 332
        if self.instance.has_agent:
            activity.sub_activity('os_boot', readable_name=ugettext_noop(
                "wait operating system loading"), interruptible=True)
Dudás Ádám committed
333 334


335
@register_operation
336
class DestroyOperation(InstanceOperation):
Dudás Ádám committed
337 338 339
    activity_code_suffix = 'destroy'
    id = 'destroy'
    name = _("destroy")
340 341
    description = _("Permanently destroy virtual machine, its network "
                    "settings and disks.")
342
    required_perms = ()
343
    resultant_state = 'DESTROYED'
Dudás Ádám committed
344

345
    def _operation(self, activity):
346
        # Destroy networks
347 348 349
        with activity.sub_activity(
                'destroying_net',
                readable_name=ugettext_noop("destroy network")):
350
            if self.instance.node:
351
                self.instance.shutdown_net()
352
            self.instance.destroy_net()
Dudás Ádám committed
353

354
        if self.instance.node:
Dudás Ádám committed
355
            # Delete virtual machine
356 357 358
            with activity.sub_activity(
                    'destroying_vm',
                    readable_name=ugettext_noop("destroy virtual machine")):
Dudás Ádám committed
359
                self.instance.delete_vm()
Dudás Ádám committed
360 361

        # Destroy disks
362 363 364
        with activity.sub_activity(
                'destroying_disks',
                readable_name=ugettext_noop("destroy disks")):
Dudás Ádám committed
365
            self.instance.destroy_disks()
Dudás Ádám committed
366

Dudás Ádám committed
367 368 369 370 371 372 373 374 375
        # Delete mem. dump if exists
        try:
            self.instance.delete_mem_dump()
        except:
            pass

        # Clear node and VNC port association
        self.instance.yield_node()
        self.instance.yield_vnc_port()
Dudás Ádám committed
376 377 378 379 380

        self.instance.destroyed_at = timezone.now()
        self.instance.save()


381
@register_operation
382
class MigrateOperation(InstanceOperation):
Dudás Ádám committed
383 384 385
    activity_code_suffix = 'migrate'
    id = 'migrate'
    name = _("migrate")
386 387
    description = _("Move virtual machine to an other worker node with a few "
                    "seconds of interruption (live migration).")
388
    required_perms = ()
389
    superuser_required = True
390
    accept_states = ('RUNNING', )
391
    async_queue = "localhost.man.slow"
Dudás Ádám committed
392

393
    def rollback(self, activity):
394 395 396
        with activity.sub_activity(
            'rollback_net', readable_name=ugettext_noop(
                "redeploy network (rollback)")):
397 398
            self.instance.deploy_net()

399
    def _operation(self, activity, to_node=None, timeout=120):
Dudás Ádám committed
400
        if not to_node:
401
            self.instance.allocate_node(activity)
402
        try:
403 404 405
            with activity.sub_activity(
                'migrate_vm', readable_name=create_readable(
                    ugettext_noop("migrate to %(node)s"), node=to_node)):
406 407 408 409
                self.instance.migrate_vm(to_node=to_node, timeout=timeout)
        except Exception as e:
            if hasattr(e, 'libvirtError'):
                self.rollback(activity)
Bach Dániel committed
410
            raise
Dudás Ádám committed
411

412
        # Shutdown networks
413 414 415
        with activity.sub_activity(
            'shutdown_net', readable_name=ugettext_noop(
                "shutdown network")):
416 417
            self.instance.shutdown_net()

Dudás Ádám committed
418 419 420 421
        # Refresh node information
        self.instance.node = to_node
        self.instance.save()
        # Estabilish network connection (vmdriver)
422 423 424
        with activity.sub_activity(
            'deploying_net', readable_name=ugettext_noop(
                "deploy network")):
Dudás Ádám committed
425
            self.instance.deploy_net()
Dudás Ádám committed
426 427


428
@register_operation
429
class RebootOperation(InstanceOperation):
Dudás Ádám committed
430 431 432
    activity_code_suffix = 'reboot'
    id = 'reboot'
    name = _("reboot")
433 434
    description = _("Warm reboot virtual machine by sending Ctrl+Alt+Del "
                    "signal to its console.")
435
    required_perms = ()
436
    accept_states = ('RUNNING', )
Dudás Ádám committed
437

438
    def _operation(self, activity, timeout=5):
Dudás Ádám committed
439
        self.instance.reboot_vm(timeout=timeout)
440 441 442
        if self.instance.has_agent:
            activity.sub_activity('os_boot', readable_name=ugettext_noop(
                "wait operating system loading"), interruptible=True)
Dudás Ádám committed
443 444


445
@register_operation
446 447 448 449
class RemoveInterfaceOperation(InstanceOperation):
    activity_code_suffix = 'remove_interface'
    id = 'remove_interface'
    name = _("remove interface")
450 451 452
    description = _("Remove the specified network interface and erase IP "
                    "address allocations, related firewall rules and "
                    "hostnames.")
453
    required_perms = ()
454
    accept_states = ('STOPPED', 'PENDING', 'RUNNING')
455

456 457
    def _operation(self, activity, user, system, interface):
        if self.instance.is_running:
458 459 460 461
            with activity.sub_activity(
                'detach_network',
                readable_name=ugettext_noop("detach network")
            ):
462
                self.instance.detach_network(interface)
463 464 465 466 467
            interface.shutdown()

        interface.destroy()
        interface.delete()

468 469
    def get_activity_name(self, kwargs):
        return create_readable(ugettext_noop("remove %(vlan)s interface"),
470
                               vlan=kwargs['interface'].vlan)
471

472

473
@register_operation
474 475 476 477
class RemoveDiskOperation(InstanceOperation):
    activity_code_suffix = 'remove_disk'
    id = 'remove_disk'
    name = _("remove disk")
478 479
    description = _("Remove the specified disk from the virtual machine, and "
                    "destroy the data.")
480
    required_perms = ()
481
    accept_states = ('STOPPED', 'PENDING', 'RUNNING')
482 483

    def _operation(self, activity, user, system, disk):
484
        if self.instance.is_running and disk.type not in ["iso"]:
485 486 487 488
            with activity.sub_activity(
                'detach_disk',
                readable_name=ugettext_noop('detach disk')
            ):
489
                self.instance.detach_disk(disk)
490 491 492 493 494
        with activity.sub_activity(
            'destroy_disk',
            readable_name=ugettext_noop('destroy disk')
        ):
            return self.instance.disks.remove(disk)
495

496 497 498
    def get_activity_name(self, kwargs):
        return create_readable(ugettext_noop('remove disk %(name)s'),
                               name=kwargs["disk"].name)
499 500


501
@register_operation
502
class ResetOperation(InstanceOperation):
Dudás Ádám committed
503 504 505
    activity_code_suffix = 'reset'
    id = 'reset'
    name = _("reset")
506
    description = _("Cold reboot virtual machine (power cycle).")
507
    required_perms = ()
508
    accept_states = ('RUNNING', )
Dudás Ádám committed
509

510
    def _operation(self, activity, timeout=5):
Dudás Ádám committed
511
        self.instance.reset_vm(timeout=timeout)
512 513 514
        if self.instance.has_agent:
            activity.sub_activity('os_boot', readable_name=ugettext_noop(
                "wait operating system loading"), interruptible=True)
Dudás Ádám committed
515 516


517
@register_operation
518
class SaveAsTemplateOperation(InstanceOperation):
Dudás Ádám committed
519 520 521
    activity_code_suffix = 'save_as_template'
    id = 'save_as_template'
    name = _("save as template")
522 523 524 525
    description = _("Save virtual machine as a template so they can be shared "
                    "with users and groups.  Anyone who has access to a "
                    "template (and to the networks it uses) will be able to "
                    "start an instance of it.")
526
    has_percentage = True
527
    abortable = True
528
    required_perms = ('vm.create_template', )
529
    accept_states = ('RUNNING', 'STOPPED')
530
    async_queue = "localhost.man.slow"
Dudás Ádám committed
531

532 533 534 535
    def is_preferred(self):
        return (self.instance.is_base and
                self.instance.status == self.instance.STATUS.RUNNING)

536 537 538 539 540 541
    @staticmethod
    def _rename(name):
        m = search(r" v(\d+)$", name)
        if m:
            v = int(m.group(1)) + 1
            name = search(r"^(.*) v(\d+)$", name).group(1)
542
        else:
543 544
            v = 1
        return "%s v%d" % (name, v)
545

546
    def on_abort(self, activity, error):
547
        if hasattr(self, 'disks'):
548 549 550
            for disk in self.disks:
                disk.destroy()

551
    def _operation(self, activity, user, system, timeout=300, name=None,
552
                   with_shutdown=True, task=None, **kwargs):
553
        if with_shutdown:
554 555
            try:
                ShutdownOperation(self.instance).call(parent_activity=activity,
556
                                                      user=user, task=task)
557 558 559
            except Instance.WrongStateError:
                pass

Dudás Ádám committed
560 561 562 563 564 565 566 567
        # prepare parameters
        params = {
            'access_method': self.instance.access_method,
            'arch': self.instance.arch,
            'boot_menu': self.instance.boot_menu,
            'description': self.instance.description,
            'lease': self.instance.lease,  # Can be problem in new VM
            'max_ram_size': self.instance.max_ram_size,
568
            'name': name or self._rename(self.instance.name),
Dudás Ádám committed
569 570 571 572 573 574 575 576 577
            'num_cores': self.instance.num_cores,
            'owner': user,
            'parent': self.instance.template,  # Can be problem
            'priority': self.instance.priority,
            'ram_size': self.instance.ram_size,
            'raw_data': self.instance.raw_data,
            'system': self.instance.system,
        }
        params.update(kwargs)
Bach Dániel committed
578
        params.pop("parent_activity", None)
Dudás Ádám committed
579

580 581
        from storage.models import Disk

Dudás Ádám committed
582 583
        def __try_save_disk(disk):
            try:
584
                return disk.save_as(task)
Dudás Ádám committed
585 586 587
            except Disk.WrongDiskTypeError:
                return disk

588
        self.disks = []
589 590 591 592 593 594 595
        for disk in self.instance.disks.all():
            with activity.sub_activity(
                'saving_disk',
                readable_name=create_readable(
                    ugettext_noop("saving disk %(name)s"),
                    name=disk.name)
            ):
596 597
                self.disks.append(__try_save_disk(disk))

Dudás Ádám committed
598 599 600 601 602
        # create template and do additional setup
        tmpl = InstanceTemplate(**params)
        tmpl.full_clean()  # Avoiding database errors.
        tmpl.save()
        try:
603
            tmpl.disks.add(*self.disks)
Dudás Ádám committed
604 605 606 607 608 609 610 611 612 613
            # create interface templates
            for i in self.instance.interface_set.all():
                i.save_as_template(tmpl)
        except:
            tmpl.delete()
            raise
        else:
            return tmpl


614
@register_operation
615
class ShutdownOperation(InstanceOperation):
Dudás Ádám committed
616 617 618
    activity_code_suffix = 'shutdown'
    id = 'shutdown'
    name = _("shutdown")
619 620 621 622
    description = _("Try to halt virtual machine by a standard ACPI signal, "
                    "allowing the operating system to keep a consistent "
                    "state. The operation will fail if the machine does not "
                    "turn itself off in a period.")
Kálmán Viktor committed
623
    abortable = True
624
    required_perms = ()
625
    accept_states = ('RUNNING', )
626
    resultant_state = 'STOPPED'
Dudás Ádám committed
627

628 629
    def _operation(self, task=None):
        self.instance.shutdown_vm(task=task)
Dudás Ádám committed
630
        self.instance.yield_node()
Dudás Ádám committed
631

632 633 634 635 636 637 638 639 640 641 642
    def on_abort(self, activity, error):
        if isinstance(error, TimeLimitExceeded):
            activity.result = humanize_exception(ugettext_noop(
                "The virtual machine did not switch off in the provided time "
                "limit. Most of the time this is caused by incorrect ACPI "
                "settings. You can also try to power off the machine from the "
                "operating system manually."), error)
            activity.resultant_state = None
        else:
            super(ShutdownOperation, self).on_abort(activity, error)

Dudás Ádám committed
643

644
@register_operation
645
class ShutOffOperation(InstanceOperation):
Dudás Ádám committed
646 647 648
    activity_code_suffix = 'shut_off'
    id = 'shut_off'
    name = _("shut off")
649 650 651 652 653 654 655
    description = _("Forcibly halt a virtual machine without notifying the "
                    "operating system. This operation will even work in cases "
                    "when shutdown does not, but the operating system and the "
                    "file systems are likely to be in an inconsistent state,  "
                    "so data loss is also possible. The effect of this "
                    "operation is the same as interrupting the power supply "
                    "of a physical machine.")
656
    required_perms = ()
657
    accept_states = ('RUNNING', )
658
    resultant_state = 'STOPPED'
Dudás Ádám committed
659

660
    def _operation(self, activity):
Dudás Ádám committed
661 662 663
        # Shutdown networks
        with activity.sub_activity('shutdown_net'):
            self.instance.shutdown_net()
Dudás Ádám committed
664

Dudás Ádám committed
665 666 667 668 669
        # Delete virtual machine
        with activity.sub_activity('delete_vm'):
            self.instance.delete_vm()

        self.instance.yield_node()
Dudás Ádám committed
670 671


672
@register_operation
673
class SleepOperation(InstanceOperation):
Dudás Ádám committed
674 675 676
    activity_code_suffix = 'sleep'
    id = 'sleep'
    name = _("sleep")
677 678 679 680 681 682 683 684
    description = _("Suspend virtual machine. This means the machine is "
                    "stopped and its memory is saved to disk, so if the "
                    "machine is waked up, all the applications will keep "
                    "running. Most of the applications will be able to "
                    "continue even after a long suspension, but those which "
                    "need a continous network connection may fail when "
                    "resumed. In the meantime, the machine will only use "
                    "storage resources, and keep network resources allocated.")
685
    required_perms = ()
686
    accept_states = ('RUNNING', )
687
    resultant_state = 'SUSPENDED'
688
    async_queue = "localhost.man.slow"
Dudás Ádám committed
689

690 691 692 693
    def is_preferred(self):
        return (not self.instance.is_base and
                self.instance.status == self.instance.STATUS.RUNNING)

Dudás Ádám committed
694 695 696 697 698 699
    def on_abort(self, activity, error):
        if isinstance(error, TimeLimitExceeded):
            activity.resultant_state = None
        else:
            activity.resultant_state = 'ERROR'

700
    def _operation(self, activity, timeout=240):
Dudás Ádám committed
701
        # Destroy networks
702 703
        with activity.sub_activity('shutdown_net', readable_name=ugettext_noop(
                "shutdown network")):
Dudás Ádám committed
704
            self.instance.shutdown_net()
Dudás Ádám committed
705 706

        # Suspend vm
707 708 709
        with activity.sub_activity('suspending',
                                   readable_name=ugettext_noop(
                                       "suspend virtual machine")):
Dudás Ádám committed
710 711 712 713
            self.instance.suspend_vm(timeout=timeout)

        self.instance.yield_node()
        # VNC port needs to be kept
Dudás Ádám committed
714 715


716
@register_operation
717
class WakeUpOperation(InstanceOperation):
Dudás Ádám committed
718 719 720
    activity_code_suffix = 'wake_up'
    id = 'wake_up'
    name = _("wake up")
721 722 723
    description = _("Wake up sleeping (suspended) virtual machine. This will "
                    "load the saved memory of the system and start the "
                    "virtual machine from this state.")
724
    required_perms = ()
725
    accept_states = ('SUSPENDED', )
726
    resultant_state = 'RUNNING'
Dudás Ádám committed
727

728
    def is_preferred(self):
729
        return self.instance.status == self.instance.STATUS.SUSPENDED
730

Dudás Ádám committed
731
    def on_abort(self, activity, error):
Bach Dániel committed
732 733 734 735
        if isinstance(error, SchedulerError):
            activity.resultant_state = None
        else:
            activity.resultant_state = 'ERROR'
Dudás Ádám committed
736

737
    def _operation(self, activity, timeout=60):
Dudás Ádám committed
738
        # Schedule vm
Dudás Ádám committed
739
        self.instance.allocate_vnc_port()
740
        self.instance.allocate_node(activity)
Dudás Ádám committed
741 742

        # Resume vm
743 744 745
        with activity.sub_activity(
            'resuming', readable_name=ugettext_noop(
                "resume virtual machine")):
Dudás Ádám committed
746
            self.instance.wake_up_vm(timeout=timeout)
Dudás Ádám committed
747 748

        # Estabilish network connection (vmdriver)
749 750 751
        with activity.sub_activity(
            'deploying_net', readable_name=ugettext_noop(
                "deploy network")):
Dudás Ádám committed
752
            self.instance.deploy_net()
Dudás Ádám committed
753

754 755 756 757
        try:
            self.instance.renew(parent_activity=activity)
        except:
            pass
Dudás Ádám committed
758 759


760
@register_operation
761 762 763 764
class RenewOperation(InstanceOperation):
    activity_code_suffix = 'renew'
    id = 'renew'
    name = _("renew")
765 766 767 768
    description = _("Virtual machines are suspended and destroyed after they "
                    "expire. This operation renews expiration times according "
                    "to the lease type. If the machine is close to the "
                    "expiration, its owner will be notified.")
769
    acl_level = "operator"
770
    required_perms = ()
771
    concurrency_check = False
772

Őry Máté committed
773
    def _operation(self, activity, lease=None, force=False, save=False):
774 775 776 777 778 779 780 781 782 783 784 785 786
        suspend, delete = self.instance.get_renew_times(lease)
        if (not force and suspend and self.instance.time_of_suspend and
                suspend < self.instance.time_of_suspend):
            raise HumanReadableException.create(ugettext_noop(
                "Renewing the machine with the selected lease would result "
                "in its suspension time get earlier than before."))
        if (not force and delete and self.instance.time_of_delete and
                delete < self.instance.time_of_delete):
            raise HumanReadableException.create(ugettext_noop(
                "Renewing the machine with the selected lease would result "
                "in its delete time get earlier than before."))
        self.instance.time_of_suspend = suspend
        self.instance.time_of_delete = delete
Őry Máté committed
787 788
        if save:
            self.instance.lease = lease
789
        self.instance.save()
790 791 792
        activity.result = create_readable(ugettext_noop(
            "Renewed to suspend at %(suspend)s and destroy at %(delete)s."),
            suspend=suspend, delete=delete)
793 794


795
@register_operation
796
class ChangeStateOperation(InstanceOperation):
Guba Sándor committed
797 798
    activity_code_suffix = 'emergency_change_state'
    id = 'emergency_change_state'
799 800 801 802 803 804
    name = _("emergency state change")
    description = _("Change the virtual machine state to NOSTATE. This "
                    "should only be used if manual intervention was needed in "
                    "the virtualization layer, and the machine has to be "
                    "redeployed without losing its storage and network "
                    "resources.")
805
    acl_level = "owner"
Guba Sándor committed
806
    required_perms = ('vm.emergency_change_state', )
807
    concurrency_check = False
808

809
    def _operation(self, user, activity, new_state="NOSTATE", interrupt=False):
810
        activity.resultant_state = new_state
811 812 813 814 815 816 817
        if interrupt:
            msg_txt = ugettext_noop("Activity is forcibly interrupted.")
            message = create_readable(msg_txt, msg_txt)
            for i in InstanceActivity.objects.filter(
                    finished__isnull=True, instance=self.instance):
                i.finish(False, result=message)
                logger.error('Forced finishing activity %s', i)
818 819


820
class NodeOperation(Operation):
821
    async_operation = abortable_async_node_operation
822
    host_cls = Node
823 824
    online_required = True
    superuser_required = True
825 826 827 828 829

    def __init__(self, node):
        super(NodeOperation, self).__init__(subject=node)
        self.node = node

830 831 832 833 834 835 836
    def check_precond(self):
        super(NodeOperation, self).check_precond()
        if self.online_required and not self.node.online:
            raise humanize_exception(ugettext_noop(
                "You cannot call this operation on an offline node."),
                Exception())

837 838
    def create_activity(self, parent, user, kwargs):
        name = self.get_activity_name(kwargs)
839 840 841 842 843 844 845 846 847 848
        if parent:
            if parent.node != self.node:
                raise ValueError("The node associated with the specified "
                                 "parent activity does not match the node "
                                 "bound to the operation.")
            if parent.user != user:
                raise ValueError("The user associated with the specified "
                                 "parent activity does not match the user "
                                 "provided as parameter.")

849 850
            return parent.create_sub(code_suffix=self.activity_code_suffix,
                                     readable_name=name)
851 852
        else:
            return NodeActivity.create(code_suffix=self.activity_code_suffix,
853 854
                                       node=self.node, user=user,
                                       readable_name=name)
855 856


857
@register_operation
858 859 860 861
class FlushOperation(NodeOperation):
    activity_code_suffix = 'flush'
    id = 'flush'
    name = _("flush")
862
    description = _("Passivate node and move all instances to other ones.")
863
    required_perms = ()
864
    async_queue = "localhost.man.slow"
865

866
    def _operation(self, activity, user):
867 868 869
        if self.node.schedule_enabled:
            PassivateOperation(self.node).call(parent_activity=activity,
                                               user=user)
870
        for i in self.node.instance_set.all():
871 872 873 874
            name = create_readable(ugettext_noop(
                "migrate %(instance)s (%(pk)s)"), instance=i.name, pk=i.pk)
            with activity.sub_activity('migrate_instance_%d' % i.pk,
                                       readable_name=name):
Bach Dániel committed
875
                i.migrate(user=user)
876 877


878 879 880 881 882 883 884 885
@register_operation
class ActivateOperation(NodeOperation):
    activity_code_suffix = 'activate'
    id = 'activate'
    name = _("activate")
    description = _("Make node active, i.e. scheduler is allowed to deploy "
                    "virtual machines to it.")
    required_perms = ()
886

887 888 889 890 891
    def check_precond(self):
        super(ActivateOperation, self).check_precond()
        if self.node.enabled and self.node.schedule_enabled:
            raise humanize_exception(ugettext_noop(
                "You cannot activate an active node."), Exception())
892

893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
    def _operation(self):
        self.node.enabled = True
        self.node.schedule_enabled = True
        self.node.save()


@register_operation
class PassivateOperation(NodeOperation):
    activity_code_suffix = 'passivate'
    id = 'passivate'
    name = _("passivate")
    description = _("Make node passive, i.e. scheduler is denied to deploy "
                    "virtual machines to it, but remaining instances and "
                    "the ones manually migrated will continue running.")
    required_perms = ()

    def check_precond(self):
        if self.node.enabled and not self.node.schedule_enabled:
            raise humanize_exception(ugettext_noop(
                "You cannot passivate a passive node."), Exception())
        super(PassivateOperation, self).check_precond()

    def _operation(self):
        self.node.enabled = True
        self.node.schedule_enabled = False
        self.node.save()


@register_operation
class DisableOperation(NodeOperation):
    activity_code_suffix = 'disable'
    id = 'disable'
    name = _("disable")
    description = _("Disable node.")
    required_perms = ()
    online_required = False
929

930 931 932 933 934 935 936 937 938
    def check_precond(self):
        if not self.node.enabled:
            raise humanize_exception(ugettext_noop(
                "You cannot disable a disabled node."), Exception())
        if self.node.instance_set.exists():
            raise humanize_exception(ugettext_noop(
                "You cannot disable a node which is hosting instances."),
                Exception())
        super(DisableOperation, self).check_precond()
939

940 941 942 943
    def _operation(self):
        self.node.enabled = False
        self.node.schedule_enabled = False
        self.node.save()
944 945


946
@register_operation
947 948 949 950
class ScreenshotOperation(InstanceOperation):
    activity_code_suffix = 'screenshot'
    id = 'screenshot'
    name = _("screenshot")
951 952 953
    description = _("Get a screenshot about the virtual machine's console. A "
                    "key will be pressed on the keyboard to stop "
                    "screensaver.")
954
    acl_level = "owner"
955
    required_perms = ()
956
    accept_states = ('RUNNING', )
957

Kálmán Viktor committed
958
    def _operation(self):
959 960 961
        return self.instance.get_screenshot(timeout=20)


962
@register_operation
Bach Dániel committed
963 964 965 966
class RecoverOperation(InstanceOperation):
    activity_code_suffix = 'recover'
    id = 'recover'
    name = _("recover")
967 968 969
    description = _("Try to recover virtual machine disks from destroyed "
                    "state. Network resources (allocations) are already lost, "
                    "so you will have to manually add interfaces afterwards.")
Bach Dániel committed
970 971
    acl_level = "owner"
    required_perms = ('vm.recover', )
972
    accept_states = ('DESTROYED', )
973
    resultant_state = 'PENDING'
Bach Dániel committed
974 975

    def check_precond(self):
976 977 978 979
        try:
            super(RecoverOperation, self).check_precond()
        except Instance.InstanceDestroyedError:
            pass
Bach Dániel committed
980 981 982 983 984 985 986 987 988 989

    def _operation(self):
        for disk in self.instance.disks.all():
            disk.destroyed = None
            disk.restore()
            disk.save()
        self.instance.destroyed_at = None
        self.instance.save()


990
@register_operation
991 992 993 994
class ResourcesOperation(InstanceOperation):
    activity_code_suffix = 'Resources change'
    id = 'resources_change'
    name = _("resources change")
995
    description = _("Change resources of a stopped virtual machine.")
996
    acl_level = "owner"
997
    required_perms = ('vm.change_resources', )
998
    accept_states = ('STOPPED', 'PENDING', )
999

1000 1001
    def _operation(self, user, activity,
                   num_cores, ram_size, max_ram_size, priority):
1002

1003 1004 1005 1006 1007
        self.instance.num_cores = num_cores
        self.instance.ram_size = ram_size
        self.instance.max_ram_size = max_ram_size
        self.instance.priority = priority

1008
        self.instance.full_clean()
1009 1010
        self.instance.save()

1011 1012 1013 1014 1015 1016
        activity.result = create_readable(ugettext_noop(
            "Priority: %(priority)s, Num cores: %(num_cores)s, "
            "Ram size: %(ram_size)s"), priority=priority, num_cores=num_cores,
            ram_size=ram_size
        )

1017

Őry Máté committed
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
class EnsureAgentMixin(object):
    accept_states = ('RUNNING', )

    def check_precond(self):
        super(EnsureAgentMixin, self).check_precond()

        last_boot_time = self.instance.activity_log.filter(
            succeeded=True, activity_code__in=(
                "vm.Instance.deploy", "vm.Instance.reset",
                "vm.Instance.reboot")).latest("finished").finished

        try:
            InstanceActivity.objects.filter(
                activity_code="vm.Instance.agent.starting",
                started__gt=last_boot_time).latest("started")
        except InstanceActivity.DoesNotExist:  # no agent since last boot
            raise self.instance.NoAgentError(self.instance)


1037
@register_operation
1038 1039
class PasswordResetOperation(EnsureAgentMixin, InstanceOperation):
    activity_code_suffix = 'password_reset'
1040 1041
    id = 'password_reset'
    name = _("password reset")
1042 1043 1044 1045 1046
    description = _("Generate and set a new login password on the virtual "
                    "machine. This operation requires the agent running. "
                    "Resetting the password is not warranted to allow you "
                    "logging in as other settings are possible to prevent "
                    "it.")
1047 1048 1049 1050
    acl_level = "owner"
    required_perms = ()

    def _operation(self):
1051 1052 1053 1054 1055
        self.instance.pw = pwgen()
        queue = self.instance.get_remote_queue_name("agent")
        agent_tasks.change_password.apply_async(
            queue=queue, args=(self.instance.vm_name, self.instance.pw))
        self.instance.save()
1056 1057


1058
@register_operation
1059
class MountStoreOperation(EnsureAgentMixin, InstanceOperation):
1060 1061 1062 1063
    activity_code_suffix = 'mount_store'
    id = 'mount_store'
    name = _("mount store")
    description = _(
1064
        "This operation attaches your personal file store. Other users who "
Őry Máté committed
1065
        "have access to this machine can see these files as well."
1066
    )
1067 1068 1069
    acl_level = "owner"
    required_perms = ()

Kálmán Viktor committed
1070 1071 1072 1073 1074 1075 1076
    def check_auth(self, user):
        super(MountStoreOperation, self).check_auth(user)
        try:
            Store(user)
        except NoStoreException:
            raise PermissionDenied  # not show the button at all

1077
    def _operation(self, user):
1078 1079
        inst = self.instance
        queue = self.instance.get_remote_queue_name("agent")
1080
        host = urlsplit(settings.STORE_URL).hostname
1081 1082
        username = Store(user).username
        password = user.profile.smb_password
1083 1084
        agent_tasks.mount_store.apply_async(
            queue=queue, args=(inst.vm_name, host, username, password))