jumpserver/apps/assets/signals_handler.py

# -*- coding: utf-8 -*-
#
from collections import defaultdict
from django.db.models.signals import (
    post_save, m2m_changed, post_delete
)
from django.db.models.aggregates import Count
from django.dispatch import receiver

from common.utils import get_logger
from common.decorator import on_transaction_commit
from orgs.utils import tmp_to_root_org
from .models import Asset, SystemUser, Node, AuthBook
from .utils import TreeService
from .tasks import (
    update_assets_hardware_info_util,
    test_asset_connectivity_util,
    push_system_user_to_assets_manual,
    push_system_user_to_assets,
    add_nodes_assets_to_system_users
)


logger = get_logger(__file__)


def update_asset_hardware_info_on_created(asset):
    logger.debug("Update asset `{}` hardware info".format(asset))
    update_assets_hardware_info_util.delay([asset])


def test_asset_conn_on_created(asset):
    logger.debug("Test asset `{}` connectivity".format(asset))
    test_asset_connectivity_util.delay([asset])


@receiver(post_save, sender=Asset)
@on_transaction_commit
def on_asset_created_or_update(sender, instance=None, created=False, **kwargs):
    """
    当资产创建时，更新硬件信息，更新可连接性
    确保资产必须属于一个节点
    """
    if created:
        logger.info("Asset create signal recv: {}".format(instance))

        # 获取资产硬件信息
        update_asset_hardware_info_on_created(instance)
        test_asset_conn_on_created(instance)

        # 确保资产存在一个节点
        has_node = instance.nodes.all().exists()
        if not has_node:
            instance.nodes.add(Node.org_root())


@receiver(post_delete, sender=Asset)
def on_asset_delete(sender, instance=None, **kwargs):
    """
    当资产删除时，刷新节点，节点中存在节点和资产的关系
    """
    logger.debug("Asset delete signal recv: {}".format(instance))
    Node.refresh_assets()


@receiver(post_save, sender=SystemUser, dispatch_uid="jms")
def on_system_user_update(sender, instance=None, created=True, **kwargs):
    """
    当系统用户更新时，可能更新了秘钥，用户名等，这时要自动推送系统用户到资产上,
    其实应该当 用户名，密码，秘钥 sudo等更新时再推送，这里偷个懒,
    这里直接取了 instance.assets 因为nodes和系统用户发生变化时，会自动将nodes下的资产
    关联到上面
    """
    if instance and not created:
        logger.info("System user update signal recv: {}".format(instance))
        assets = instance.assets.all().valid()
        push_system_user_to_assets.delay(instance, assets)


@receiver(m2m_changed, sender=SystemUser.assets.through)
def on_system_user_assets_change(sender, instance=None, action='', model=None, pk_set=None, **kwargs):
    """
    当系统用户和资产关系发生变化时，应该重新推送系统用户到新添加的资产中
    """
    if action != "post_add":
        return
    logger.debug("System user assets change signal recv: {}".format(instance))
    queryset = model.objects.filter(pk__in=pk_set)
    if model == Asset:
        system_users = [instance]
        assets = queryset
    else:
        system_users = queryset
        assets = [instance]
    for system_user in system_users:
        push_system_user_to_assets.delay(system_user, assets)


@receiver(m2m_changed, sender=SystemUser.users.through)
def on_system_user_users_change(sender, instance=None, action='', model=None, pk_set=None, **kwargs):
    """
    当系统用户和用户关系发生变化时，应该重新推送系统用户资产中
    """
    if action != "post_add":
        return
    if not instance.username_same_with_user:
        return
    logger.debug("System user users change signal recv: {}".format(instance))
    queryset = model.objects.filter(pk__in=pk_set)
    if model == SystemUser:
        system_users = queryset
    else:
        system_users = [instance]
    for s in system_users:
        push_system_user_to_assets_manual.delay(s)


@receiver(m2m_changed, sender=SystemUser.nodes.through)
def on_system_user_nodes_change(sender, instance=None, action=None, model=None, pk_set=None, **kwargs):
    """
    当系统用户和节点关系发生变化时，应该将节点下资产关联到新的系统用户上
    """
    if action != "post_add":
        return
    logger.info("System user nodes update signal recv: {}".format(instance))

    queryset = model.objects.filter(pk__in=pk_set)
    if model == Node:
        nodes_keys = queryset.values_list('key', flat=True)
        system_users = [instance]
    else:
        nodes_keys = [instance.key]
        system_users = queryset
    add_nodes_assets_to_system_users.delay(nodes_keys, system_users)


@receiver(m2m_changed, sender=SystemUser.groups.through)
def on_system_user_groups_change(sender, instance=None, action=None, model=None,
                                 pk_set=None, reverse=False, **kwargs):
    """
    当系统用户和用户组关系发生变化时，应该将组下用户关联到新的系统用户上
    """
    if action != "post_add" or reverse:
        return
    logger.info("System user groups update signal recv: {}".format(instance))
    groups = model.objects.filter(pk__in=pk_set).annotate(users_count=Count("users"))
    users = groups.filter(users_count__gt=0).values_list('users', flat=True)
    instance.users.add(*tuple(users))


@receiver(m2m_changed, sender=Asset.nodes.through)
def on_asset_nodes_change(sender, instance=None, action='', **kwargs):
    """
    资产节点发生变化时，刷新节点
    """
    if action.startswith('post'):
        logger.debug("Asset nodes change signal recv: {}".format(instance))
        Node.refresh_assets()
        with tmp_to_root_org():
            Node.refresh_assets()


@receiver(m2m_changed, sender=Asset.nodes.through)
def on_asset_nodes_add(sender, instance=None, action='', model=None, pk_set=None, **kwargs):
    """
    当资产的节点发生变化时，或者 当节点的资产关系发生变化时，
    节点下新增的资产，添加到节点关联的系统用户中
    """
    if action != "post_add":
        return
    logger.debug("Assets node add signal recv: {}".format(action))
    if model == Node:
        nodes = model.objects.filter(pk__in=pk_set).values_list('key', flat=True)
        assets = [instance.id]
    else:
        nodes = [instance.key]
        assets = model.objects.filter(pk__in=pk_set).values_list('id', flat=True)
    # 节点资产发生变化时，将资产关联到节点及祖先节点关联的系统用户, 只关注新增的
    nodes_ancestors_keys = set()
    node_tree = TreeService.new()
    for node in nodes:
        ancestors_keys = node_tree.ancestors_ids(nid=node)
        nodes_ancestors_keys.update(ancestors_keys)
    system_users = SystemUser.objects.filter(nodes__key__in=nodes_ancestors_keys)

    system_users_assets = defaultdict(set)
    for system_user in system_users:
        system_users_assets[system_user].update(set(assets))
    for system_user, _assets in system_users_assets.items():
        system_user.assets.add(*tuple(_assets))


@receiver(m2m_changed, sender=Asset.nodes.through)
def on_asset_nodes_remove(sender, instance=None, action='', model=None,
                          pk_set=None, **kwargs):

    """
    监控资产删除节点关系, 或节点删除资产，避免产生游离资产
    """
    if action not in ["post_remove", "pre_clear", "post_clear"]:
        return
    if action == "pre_clear":
        if model == Node:
            instance._nodes = list(instance.nodes.all())
        else:
            instance._assets = list(instance.assets.all())
        return
    logger.debug("Assets node remove signal recv: {}".format(action))
    if action == "post_remove":
        queryset = model.objects.filter(pk__in=pk_set)
    else:
        if model == Node:
            queryset = instance._nodes
        else:
            queryset = instance._assets
    if model == Node:
        assets = [instance]
    else:
        assets = queryset
    if isinstance(assets, list):
        assets_not_has_node = []
        for asset in assets:
            if asset.nodes.all().count() == 0:
                assets_not_has_node.append(asset.id)
    else:
        assets_not_has_node = assets.annotate(nodes_count=Count('nodes'))\
            .filter(nodes_count=0).values_list('id', flat=True)
    Node.org_root().assets.add(*tuple(assets_not_has_node))


@receiver([post_save, post_delete], sender=Node)
def on_node_update_or_created(sender, **kwargs):
    # 刷新节点
    Node.refresh_nodes()
    with tmp_to_root_org():
        Node.refresh_nodes()