console/SWSCloudCore/controllers/tasks/server.py

# coding: utf-8

import json
from SWSCloudCore import models
from SWSCloudCore.controllers.containers.server import ControllerContainersServer
from SWSCloudCore.controllers.vms.server import Controller_VMS_Server


class ControllerTasksServer:
    def __init__(self, server_id):
        self.server_id = server_id

    def queue_item_oldest_get(self, status=0):
        """
        Вытащить самую старую задачу из всех активных
        :param status:
        :return:
        """
        return models.Tasks.select().where(
            models.Tasks.server == self.server_id,
            models.Tasks.status == status
        ).order_by(models.Tasks.created.asc()).get()

    def count(self, status=0):
        return models.Tasks.select().where(
            models.Tasks.server == self.server_id,
            models.Tasks.status == status
        ).count()

    def get(self, status=0):
        return models.Tasks.select().where(
            models.Tasks.server == self.server_id,
            models.Tasks.status == status
        ).execute()

    def update(self, task_id, status):
        # get origin status
        if models.Tasks.select().where(models.Tasks.id == task_id).count() == 0:
            return False

        controller_vm = Controller_VMS_Server()
        controller_container = ControllerContainersServer()
        task = self.get_item(task_id)

        # container statuses:
        # 0 - inactive
        # 1 - active
        # 2 - activation
        # 3 - deactivation
        # 4 - creating
        # 5 - deleting

        lxc_tasks_list = ['container_start', 'container_stop', 'container_create',
                          'container_restart', 'container_delete']
        qemu_tasks_list = ['vm_create', 'vm_start', 'vm_stop', 'vm_restart', 'vm_delete']

        if status == 1:
            if task['task'] in lxc_tasks_list:
                if task['task'] == 'container_start':
                    controller_container.status_set(task['plain']['container_id'], 2)
                if task['task'] == 'container_stop':
                    controller_container.status_set(task['plain']['container_id'], 3)

            if task['task'] in qemu_tasks_list:
                if task['task'] == 'vm_start':
                    controller_vm.status_set(task['plain']['vm_id'], 2)
                if task['task'] == 'vm_stop':
                    controller_vm.status_set(task['plain']['vm_id'], 3)

        if status == 2:
            if task['task'] in qemu_tasks_list:
                if task['task'] == 'vm_create':
                    controller_vm.status_set(task['plain']['vm_id'], 1)
                if task['task'] == 'vm_start':
                    controller_vm.status_set(task['plain']['vm_id'], 1)
                if task['task'] == 'vm_stop':
                    controller_vm.status_set(task['plain']['vm_id'], 0)
                if task['task'] == 'vm_restart':
                    controller_vm.status_set(task['plain']['vm_id'], 1)
                if task['task'] == 'vm_delete':
                    # не имеет смысла менять статус, т.к. контейнер придётся удалять
                    # controllercontainer.status_set(task['plain']['container_id'], 2)

                    ns = models.Ips.update(status=0).where(
                        models.Ips.ipv4 << models.Vms.select(models.Vms.ipv4).where(
                            models.Vms.id == task['plain']['vm_id'],
                            models.Vms.ipv4 != ''
                        )
                    )
                    ns.execute()

                    ns = models.Ips.update(status=0).where(
                        models.Ips.ipv6 << models.Vms.select(models.Vms.ipv6).where(
                            models.Vms.id == task['plain']['vm_id'],
                            models.Vms.ipv6 != ''
                        )
                    )
                    ns.execute()

                    # delete all container statistics
                    # del_stats = models.ContainersStatistics.delete().where(
                    #     models.ContainersStatistics.container == task['plain']['container_id']
                    # )
                    # del_stats.execute()

                    # delete stats state
                    # del_stats_state = models.ContainersStatisticsState.delete().where(
                    #     models.ContainersStatisticsState.container == task['plain']['container_id']
                    # )
                    # del_stats_state.execute()

                    #
                    del_vm = models.Vms.delete().where(models.Vms.id == task['plain']['vm_id'])
                    del_vm.execute()

            if task['task'] in lxc_tasks_list:
                if task['task'] == 'container_create':
                    controller_container.status_set(task['plain']['container_id'], 1)
                if task['task'] == 'container_start':
                    controller_container.status_set(task['plain']['container_id'], 1)
                if task['task'] == 'container_stop':
                    controller_container.status_set(task['plain']['container_id'], 0)
                if task['task'] == 'container_restart':
                    controller_container.status_set(task['plain']['container_id'], 1)
                if task['task'] == 'container_delete':
                    # не имеет смысла менять статус, т.к. контейнер придётся удалять
                    # controllercontainer.status_set(task['plain']['container_id'], 2)

                    ns = models.Ips.update(status=0).where(
                        models.Ips.ipv4 << models.Containers.select(models.Containers.ipv4).where(
                            models.Containers.id == task['plain']['container_id'],
                            models.Containers.ipv4 != ''
                        )
                    )
                    ns.execute()

                    ns = models.Ips.update(status=0).where(
                        models.Ips.ipv6 << models.Containers.select(models.Containers.ipv6).where(
                            models.Containers.id == task['plain']['container_id'],
                            models.Containers.ipv6 != ''
                        )
                    )
                    ns.execute()

                    # delete all container statistics
                    del_stats = models.ContainersStatistics.delete().where(
                        models.ContainersStatistics.container == task['plain']['container_id']
                    )
                    del_stats.execute()

                    # delete stats state
                    del_stats_state = models.ContainersStatisticsState.delete().where(
                        models.ContainersStatisticsState.container == task['plain']['container_id']
                    )
                    del_stats_state.execute()

                    #
                    del_container = models.Containers.delete().where(models.Containers.id == task['plain']['container_id'])
                    del_container.execute()

        task = models.Tasks.update(status=status).where(models.Tasks.id == task_id)
        task.execute()

        return True

    def get_item(self, task_id):
        get_task = models.Tasks.select().where(models.Tasks.id == task_id).get()
        return {
            'id': get_task.id,
            'datacenter': get_task.datacenter.id,
            'server': get_task.server.id,
            'user': get_task.user.id,
            'created': get_task.created,
            'task': get_task.task,
            'status': get_task.status,
            'plain': json.loads(get_task.plain)
        }