|
|
# -*- coding: utf-8 -*-
|
|
|
#
|
|
|
|
|
|
from django.db.models import F
|
|
|
from django.db.transaction import atomic
|
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
from rest_framework import serializers
|
|
|
|
|
|
from accounts.models import Account
|
|
|
from accounts.serializers import AccountSerializer
|
|
|
from common.const import UUID_PATTERN
|
|
|
from common.serializers import (
|
|
|
WritableNestedModelSerializer, SecretReadableMixin,
|
|
|
CommonModelSerializer, MethodSerializer
|
|
|
)
|
|
|
from common.serializers.common import DictSerializer
|
|
|
from common.serializers.fields import LabeledChoiceField
|
|
|
from orgs.mixins.serializers import BulkOrgResourceModelSerializer
|
|
|
from ...const import Category, AllTypes
|
|
|
from ...models import Asset, Node, Platform, Label, Protocol
|
|
|
|
|
|
__all__ = [
|
|
|
'AssetSerializer', 'AssetSimpleSerializer', 'MiniAssetSerializer',
|
|
|
'AssetTaskSerializer', 'AssetsTaskSerializer', 'AssetProtocolsSerializer',
|
|
|
'AssetDetailSerializer', 'DetailMixin', 'AssetAccountSerializer',
|
|
|
'AccountSecretSerializer', 'AssetProtocolsPermsSerializer', 'AssetLabelSerializer'
|
|
|
]
|
|
|
|
|
|
|
|
|
class AssetProtocolsSerializer(serializers.ModelSerializer):
|
|
|
port = serializers.IntegerField(required=False, allow_null=True, max_value=65535, min_value=0)
|
|
|
|
|
|
def to_file_representation(self, data):
|
|
|
return '{name}/{port}'.format(**data)
|
|
|
|
|
|
def to_file_internal_value(self, data):
|
|
|
name, port = data.split('/')
|
|
|
return {'name': name, 'port': port}
|
|
|
|
|
|
class Meta:
|
|
|
model = Protocol
|
|
|
fields = ['name', 'port']
|
|
|
|
|
|
|
|
|
class AssetProtocolsPermsSerializer(AssetProtocolsSerializer):
|
|
|
class Meta(AssetProtocolsSerializer.Meta):
|
|
|
fields = AssetProtocolsSerializer.Meta.fields + ['public', 'setting']
|
|
|
|
|
|
|
|
|
class AssetLabelSerializer(serializers.ModelSerializer):
|
|
|
class Meta:
|
|
|
model = Label
|
|
|
fields = ['id', 'name', 'value']
|
|
|
extra_kwargs = {
|
|
|
# 取消默认唯一键的校验
|
|
|
'id': {'validators': []},
|
|
|
'name': {'required': False},
|
|
|
'value': {'required': False},
|
|
|
}
|
|
|
|
|
|
|
|
|
class AssetPlatformSerializer(serializers.ModelSerializer):
|
|
|
class Meta:
|
|
|
model = Platform
|
|
|
fields = ['id', 'name']
|
|
|
extra_kwargs = {
|
|
|
'name': {'required': False}
|
|
|
}
|
|
|
|
|
|
|
|
|
class AssetAccountSerializer(AccountSerializer):
|
|
|
add_org_fields = False
|
|
|
asset = serializers.PrimaryKeyRelatedField(queryset=Asset.objects, required=False, write_only=True)
|
|
|
clone_id = None
|
|
|
|
|
|
def to_internal_value(self, data):
|
|
|
# 导入时，data有时为str
|
|
|
if isinstance(data, str):
|
|
|
return super().to_internal_value(data)
|
|
|
|
|
|
clone_id = data.pop('id', None)
|
|
|
ret = super().to_internal_value(data)
|
|
|
self.clone_id = clone_id
|
|
|
return ret
|
|
|
|
|
|
def set_secret(self, attrs):
|
|
|
_id = self.clone_id
|
|
|
if not _id:
|
|
|
return attrs
|
|
|
|
|
|
account = Account.objects.get(id=_id)
|
|
|
attrs['secret'] = account.secret
|
|
|
return attrs
|
|
|
|
|
|
def validate(self, attrs):
|
|
|
attrs = super().validate(attrs)
|
|
|
return self.set_secret(attrs)
|
|
|
|
|
|
class Meta(AccountSerializer.Meta):
|
|
|
fields = [
|
|
|
f for f in AccountSerializer.Meta.fields
|
|
|
if f not in ['spec_info']
|
|
|
]
|
|
|
extra_kwargs = {
|
|
|
**AccountSerializer.Meta.extra_kwargs,
|
|
|
}
|
|
|
|
|
|
|
|
|
class AccountSecretSerializer(SecretReadableMixin, CommonModelSerializer):
|
|
|
class Meta:
|
|
|
model = Account
|
|
|
fields = [
|
|
|
'name', 'username', 'privileged', 'secret_type', 'secret',
|
|
|
]
|
|
|
extra_kwargs = {
|
|
|
'secret': {'write_only': False},
|
|
|
}
|
|
|
|
|
|
|
|
|
class AssetSerializer(BulkOrgResourceModelSerializer, WritableNestedModelSerializer):
|
|
|
category = LabeledChoiceField(choices=Category.choices, read_only=True, label=_('Category'))
|
|
|
type = LabeledChoiceField(choices=AllTypes.choices(), read_only=True, label=_('Type'))
|
|
|
labels = AssetLabelSerializer(many=True, required=False, label=_('Label'))
|
|
|
protocols = AssetProtocolsSerializer(many=True, required=False, label=_('Protocols'), default=())
|
|
|
accounts = AssetAccountSerializer(many=True, required=False, allow_null=True, write_only=True, label=_('Account'))
|
|
|
nodes_display = serializers.ListField(read_only=False, required=False, label=_("Node path"))
|
|
|
_accounts = None
|
|
|
|
|
|
class Meta:
|
|
|
model = Asset
|
|
|
fields_mini = ['id', 'name', 'address']
|
|
|
fields_small = fields_mini + ['is_active', 'comment']
|
|
|
fields_fk = ['domain', 'platform']
|
|
|
fields_m2m = [
|
|
|
'nodes', 'labels', 'protocols',
|
|
|
'nodes_display', 'accounts',
|
|
|
]
|
|
|
read_only_fields = [
|
|
|
'category', 'type', 'connectivity', 'auto_config',
|
|
|
'date_verified', 'created_by', 'date_created',
|
|
|
]
|
|
|
fields = fields_small + fields_fk + fields_m2m + read_only_fields
|
|
|
fields_unexport = ['auto_config']
|
|
|
extra_kwargs = {
|
|
|
'auto_config': {'label': _('Auto info')},
|
|
|
'name': {'label': _("Name")},
|
|
|
'address': {'label': _('Address')},
|
|
|
'nodes_display': {'label': _('Node path')},
|
|
|
'nodes': {'allow_empty': True},
|
|
|
}
|
|
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
|
super().__init__(*args, **kwargs)
|
|
|
self._init_field_choices()
|
|
|
self._extract_accounts()
|
|
|
|
|
|
def _extract_accounts(self):
|
|
|
if not getattr(self, 'initial_data', None):
|
|
|
return
|
|
|
if isinstance(self.initial_data, list):
|
|
|
return
|
|
|
accounts = self.initial_data.pop('accounts', None)
|
|
|
self._accounts = accounts
|
|
|
|
|
|
def _get_protocols_required_default(self):
|
|
|
platform = self._asset_platform
|
|
|
platform_protocols = platform.protocols.all()
|
|
|
protocols_default = [p for p in platform_protocols if p.default]
|
|
|
protocols_required = [p for p in platform_protocols if p.required or p.primary]
|
|
|
return protocols_required, protocols_default
|
|
|
|
|
|
def _set_protocols_default(self):
|
|
|
if not hasattr(self, 'initial_data'):
|
|
|
return
|
|
|
protocols = self.initial_data.get('protocols')
|
|
|
if protocols is not None:
|
|
|
return
|
|
|
if getattr(self, 'instance', None):
|
|
|
return
|
|
|
|
|
|
protocols_required, protocols_default = self._get_protocols_required_default()
|
|
|
protocol_map = {str(protocol.id): protocol for protocol in protocols_required + protocols_default}
|
|
|
protocols = list(protocol_map.values())
|
|
|
protocols_data = [{'name': p.name, 'port': p.port} for p in protocols]
|
|
|
self.initial_data['protocols'] = protocols_data
|
|
|
|
|
|
def _init_field_choices(self):
|
|
|
request = self.context.get('request')
|
|
|
if not request:
|
|
|
return
|
|
|
category = request.path.strip('/').split('/')[-1].rstrip('s')
|
|
|
field_category = self.fields.get('category')
|
|
|
if not field_category:
|
|
|
return
|
|
|
field_category.choices = Category.filter_choices(category)
|
|
|
field_type = self.fields.get('type')
|
|
|
if not field_type:
|
|
|
return
|
|
|
field_type.choices = AllTypes.filter_choices(category)
|
|
|
|
|
|
@classmethod
|
|
|
def setup_eager_loading(cls, queryset):
|
|
|
""" Perform necessary eager loading of data. """
|
|
|
queryset = queryset.prefetch_related('domain', 'nodes', 'labels', 'protocols') \
|
|
|
.prefetch_related('platform', 'platform__automation') \
|
|
|
.annotate(category=F("platform__category")) \
|
|
|
.annotate(type=F("platform__type"))
|
|
|
return queryset
|
|
|
|
|
|
@staticmethod
|
|
|
def perform_nodes_display_create(instance, nodes_display):
|
|
|
if not nodes_display:
|
|
|
return
|
|
|
nodes_to_set = []
|
|
|
for full_value in nodes_display:
|
|
|
if not full_value.startswith('/'):
|
|
|
full_value = '/' + instance.org.name + '/' + full_value
|
|
|
node = Node.objects.filter(full_value=full_value).first()
|
|
|
if node:
|
|
|
nodes_to_set.append(node)
|
|
|
else:
|
|
|
node = Node.create_node_by_full_value(full_value)
|
|
|
nodes_to_set.append(node)
|
|
|
instance.nodes.set(nodes_to_set)
|
|
|
|
|
|
@property
|
|
|
def _asset_platform(self):
|
|
|
platform_id = self.initial_data.get('platform')
|
|
|
if isinstance(platform_id, dict):
|
|
|
platform_id = platform_id.get('id') or platform_id.get('pk')
|
|
|
|
|
|
if not platform_id and self.instance:
|
|
|
platform = self.instance.platform
|
|
|
else:
|
|
|
platform = Platform.objects.filter(id=platform_id).first()
|
|
|
|
|
|
if not platform:
|
|
|
raise serializers.ValidationError({'platform': _("Platform not exist")})
|
|
|
return platform
|
|
|
|
|
|
def validate_domain(self, value):
|
|
|
platform = self._asset_platform
|
|
|
if platform.domain_enabled:
|
|
|
return value
|
|
|
else:
|
|
|
return None
|
|
|
|
|
|
def validate_nodes(self, nodes):
|
|
|
if nodes:
|
|
|
return nodes
|
|
|
nodes_display = self.initial_data.get('nodes_display')
|
|
|
if nodes_display:
|
|
|
return nodes
|
|
|
default_node = Node.org_root()
|
|
|
request = self.context.get('request')
|
|
|
if not request:
|
|
|
return [default_node]
|
|
|
node_id = request.query_params.get('node_id')
|
|
|
if not node_id:
|
|
|
return [default_node]
|
|
|
nodes = Node.objects.filter(id=node_id)
|
|
|
return nodes
|
|
|
|
|
|
def is_valid(self, raise_exception=False):
|
|
|
self._set_protocols_default()
|
|
|
return super().is_valid(raise_exception=raise_exception)
|
|
|
|
|
|
def validate_protocols(self, protocols_data):
|
|
|
# 目的是去重
|
|
|
protocols_data_map = {p['name']: p for p in protocols_data}
|
|
|
for p in protocols_data:
|
|
|
port = p.get('port', 0)
|
|
|
if port < 0 or port > 65535:
|
|
|
error = p.get('name') + ': ' + _("port out of range (0-65535)")
|
|
|
raise serializers.ValidationError(error)
|
|
|
|
|
|
protocols_required, __ = self._get_protocols_required_default()
|
|
|
protocols_not_found = [p.name for p in protocols_required if p.name not in protocols_data_map]
|
|
|
if protocols_not_found:
|
|
|
raise serializers.ValidationError({
|
|
|
'protocols': _("Protocol is required: {}").format(', '.join(protocols_not_found))
|
|
|
})
|
|
|
return protocols_data_map.values()
|
|
|
|
|
|
@staticmethod
|
|
|
def update_account_su_from(accounts, include_su_from_accounts):
|
|
|
if not include_su_from_accounts:
|
|
|
return
|
|
|
name_map = {account.name: account for account in accounts}
|
|
|
username_secret_type_map = {
|
|
|
(account.username, account.secret_type): account for account in accounts
|
|
|
}
|
|
|
|
|
|
for name, username_secret_type in include_su_from_accounts.items():
|
|
|
account = name_map.get(name)
|
|
|
if not account:
|
|
|
continue
|
|
|
su_from_account = username_secret_type_map.get(username_secret_type)
|
|
|
if su_from_account:
|
|
|
account.su_from = su_from_account
|
|
|
account.save()
|
|
|
|
|
|
def accounts_create(self, accounts_data, asset):
|
|
|
from accounts.models import AccountTemplate
|
|
|
if not accounts_data:
|
|
|
return
|
|
|
|
|
|
if not isinstance(accounts_data[0], dict):
|
|
|
raise serializers.ValidationError({'accounts': _("Invalid data")})
|
|
|
|
|
|
su_from_name_username_secret_type_map = {}
|
|
|
for data in accounts_data:
|
|
|
data['asset'] = asset.id
|
|
|
name = data.get('name')
|
|
|
su_from = data.pop('su_from', None)
|
|
|
template_id = data.get('template', None)
|
|
|
if template_id:
|
|
|
template = AccountTemplate.objects.get(id=template_id)
|
|
|
if template and template.su_from:
|
|
|
su_from_name_username_secret_type_map[template.name] = (
|
|
|
template.su_from.username, template.su_from.secret_type
|
|
|
)
|
|
|
elif isinstance(su_from, dict):
|
|
|
su_from = Account.objects.get(id=su_from.get('id'))
|
|
|
su_from_name_username_secret_type_map[name] = (
|
|
|
su_from.username, su_from.secret_type
|
|
|
)
|
|
|
s = AssetAccountSerializer(data=accounts_data, many=True)
|
|
|
s.is_valid(raise_exception=True)
|
|
|
accounts = s.save()
|
|
|
self.update_account_su_from(accounts, su_from_name_username_secret_type_map)
|
|
|
|
|
|
@atomic
|
|
|
def create(self, validated_data):
|
|
|
nodes_display = validated_data.pop('nodes_display', '')
|
|
|
instance = super().create(validated_data)
|
|
|
self.accounts_create(self._accounts, instance)
|
|
|
self.perform_nodes_display_create(instance, nodes_display)
|
|
|
return instance
|
|
|
|
|
|
@staticmethod
|
|
|
def sync_platform_protocols(instance, old_platform):
|
|
|
platform = instance.platform
|
|
|
|
|
|
if str(old_platform.id) == str(instance.platform_id):
|
|
|
return
|
|
|
|
|
|
platform_protocols = {
|
|
|
p['name']: p['port']
|
|
|
for p in platform.protocols.values('name', 'port')
|
|
|
}
|
|
|
|
|
|
protocols = set(instance.protocols.values_list('name', flat=True))
|
|
|
protocol_names = set(platform_protocols) - protocols
|
|
|
objs = []
|
|
|
for name in protocol_names:
|
|
|
objs.append(
|
|
|
Protocol(
|
|
|
name=name,
|
|
|
port=platform_protocols[name],
|
|
|
asset_id=instance.id,
|
|
|
)
|
|
|
)
|
|
|
Protocol.objects.bulk_create(objs)
|
|
|
|
|
|
@atomic
|
|
|
def update(self, instance, validated_data):
|
|
|
old_platform = instance.platform
|
|
|
nodes_display = validated_data.pop('nodes_display', '')
|
|
|
instance = super().update(instance, validated_data)
|
|
|
self.sync_platform_protocols(instance, old_platform)
|
|
|
self.perform_nodes_display_create(instance, nodes_display)
|
|
|
return instance
|
|
|
|
|
|
|
|
|
class DetailMixin(serializers.Serializer):
|
|
|
accounts = AssetAccountSerializer(many=True, required=False, label=_('Accounts'))
|
|
|
spec_info = MethodSerializer(label=_('Spec info'), read_only=True)
|
|
|
gathered_info = MethodSerializer(label=_('Gathered info'), read_only=True)
|
|
|
auto_config = serializers.DictField(read_only=True, label=_('Auto info'))
|
|
|
|
|
|
def get_instance(self):
|
|
|
request = self.context.get('request')
|
|
|
if not self.instance and UUID_PATTERN.findall(request.path):
|
|
|
pk = UUID_PATTERN.findall(request.path)[0]
|
|
|
self.instance = Asset.objects.filter(id=pk).first()
|
|
|
return self.instance
|
|
|
|
|
|
def get_field_names(self, declared_fields, info):
|
|
|
names = super().get_field_names(declared_fields, info)
|
|
|
names.extend([
|
|
|
'accounts', 'gathered_info', 'spec_info',
|
|
|
'auto_config',
|
|
|
])
|
|
|
return names
|
|
|
|
|
|
def get_category(self):
|
|
|
request = self.context.get('request')
|
|
|
if request.query_params.get('category'):
|
|
|
category = request.query_params.get('category')
|
|
|
else:
|
|
|
instance = self.get_instance()
|
|
|
category = instance.category if instance else 'host'
|
|
|
return category
|
|
|
|
|
|
def get_gathered_info_serializer(self):
|
|
|
category = self.get_category()
|
|
|
from .info.gathered import category_gathered_serializer_map
|
|
|
serializer_cls = category_gathered_serializer_map.get(category, DictSerializer)
|
|
|
return serializer_cls()
|
|
|
|
|
|
def get_spec_info_serializer(self):
|
|
|
category = self.get_category()
|
|
|
from .info.spec import category_spec_serializer_map
|
|
|
serializer_cls = category_spec_serializer_map.get(category, DictSerializer)
|
|
|
return serializer_cls()
|
|
|
|
|
|
|
|
|
class AssetDetailSerializer(DetailMixin, AssetSerializer):
|
|
|
pass
|
|
|
|
|
|
|
|
|
class MiniAssetSerializer(serializers.ModelSerializer):
|
|
|
class Meta:
|
|
|
model = Asset
|
|
|
fields = AssetSerializer.Meta.fields_mini
|
|
|
|
|
|
|
|
|
class AssetSimpleSerializer(serializers.ModelSerializer):
|
|
|
class Meta:
|
|
|
model = Asset
|
|
|
fields = [
|
|
|
'id', 'name', 'address', 'port',
|
|
|
'connectivity', 'date_verified'
|
|
|
]
|
|
|
|
|
|
|
|
|
class AssetsTaskSerializer(serializers.Serializer):
|
|
|
ACTION_CHOICES = (
|
|
|
('refresh', 'refresh'),
|
|
|
('test', 'test'),
|
|
|
)
|
|
|
task = serializers.CharField(read_only=True)
|
|
|
action = serializers.ChoiceField(choices=ACTION_CHOICES, write_only=True)
|
|
|
assets = serializers.PrimaryKeyRelatedField(
|
|
|
queryset=Asset.objects, required=False, allow_empty=True, many=True
|
|
|
)
|
|
|
|
|
|
|
|
|
class AssetTaskSerializer(AssetsTaskSerializer):
|
|
|
ACTION_CHOICES = tuple(list(AssetsTaskSerializer.ACTION_CHOICES) + [
|
|
|
('push_system_user', 'push_system_user'),
|
|
|
('test_system_user', 'test_system_user')
|
|
|
])
|
|
|
action = serializers.ChoiceField(choices=ACTION_CHOICES, write_only=True)
|
|
|
asset = serializers.PrimaryKeyRelatedField(
|
|
|
queryset=Asset.objects, required=False, allow_empty=True, many=False
|
|
|
)
|
|
|
accounts = serializers.PrimaryKeyRelatedField(
|
|
|
queryset=Account.objects, required=False, allow_empty=True, many=True
|
|
|
)
|
