xref: /build/ohos/hisysevent/gen_def_from_all_yaml.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) 2021-2023 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys
import os
import stat
import json
import argparse
import zipfile

from collections import Counter

sys.path.append(
    os.path.dirname(
        os.path.dirname(
            os.path.dirname(os.path.dirname(os.path.abspath(__file__))))))

from third_party.PyYAML.lib import yaml  # noqa: E402

_DUPLICATE_KEY_DEF = "duplicate key definition"
_EMPTY_YAML = "empty yaml file input"
_INVALID_YAML = "invalid yaml format"
_DUPLICATE_DOMAIN = "duplicate domain"
_INVALID_DOMAIN_NUMBER = "invalid domain number"
_INVALID_DOMAIN_LENGTH = "invalid domain length"
_INVALID_DOMAIN_CHAR = "invalid domain character"
_INVALID_DOMAIN_CHAR_HEAD = "invalid domain character head"
_INVALID_EVENT_NUMBER = "invalid event number"
_INVALID_EVENT_LENGTH = "invalid event length"
_INVALID_EVENT_CHAR = "invalid event character"
_INVALID_EVENT_CHAR_HEAD = "invalid event character head"
_MISSING_EVENT_BASE = "missing event base"
_MISSING_EVENT_TYPE = "missing event type"
_INVALID_EVENT_TYPE = "invalid event type"
_MISSING_EVENT_LEVEL = "missing event level"
_INVALID_EVENT_LEVEL = "invalid event level"
_MISSING_EVENT_DESC = "missing event desc"
_INVALID_EVENT_DESC_LENGTH = "invalid event desc length"
_INVALID_EVENT_TAG_NUM = "invalid event tag number"
_INVALID_EVENT_TAG_LEN = "invalid event tag length"
_INVALID_EVENT_TAG_CHAR = "invalid event tag character"
_DUPLICATE_EVENT_TAG = "duplicate event tag"
_INVALID_EVENT_BASE_KEY = "invalid event base key"
_INVALID_EVENT_PARAM_NUM = "invalid event param number"
_INVALID_EVENT_PARAM_LEN = "invalid event param length"
_INVALID_EVENT_PARAM_CHAR = "invalid event param character"
_INVALID_EVENT_PARAM_CHAR_HEAD = "invalid event param character head"
_MISSING_EVENT_PARAM_TYPE = "missing event param type"
_INVALID_EVENT_PARAM_TYPE = "invalid event param type"
_INVALID_EVENT_PARAM_ARRSIZE = "invalid event param arrsize"
_MISSING_EVENT_PARAM_DESC = "missing event param desc"
_INVALID_EVENT_PARAM_DESC_LEN = "invalid event param desc length"
_INVALID_EVENT_PARAM_KEY = "invalid event param key"
_DEPRECATED_EVENT_NAME_PREFIX = "deprecated event name prefix"
_DEPRECATED_PARAM_NAME_PREFIX = "deprecated param name prefix"
_DEPRECATED_TAG_NAME = "deprecated tag name"
_DEPRECATED_EVENT_DESC_NAME = "deprecated event desc name"
_DEPRECATED_PARAM_DESC_NAME = "deprecated param desc name"
_INVALID_DOMAIN_DEF = "invalid definition type for domain"
_INVALID_EVENT_DEF = "invalid definition type for event"
_INVALID_EVENT_BASE_DEF = "invalid definition type for event base"
_INVALID_EVENT_TYPE_DEF = "invalid definition type for event type"
_INVALID_EVENT_LEVEL_DEF = "invalid definition type for event level"
_INVALID_EVENT_DESC_DEF = "invalid definition type for event desc"
_INVALID_EVENT_TAG_DEF = "invalid definition type for event tag"
_INVALID_EVENT_PRESERVE_DEF = "invalid definition type for event preserve"
_INVALID_EVENT_PARAM_DEF = "invalid definition type for event param"
_INVALID_PARAM_TYPE_DEF = "invalid definition type for param type"
_INVALID_PARAM_ARRSIZE_DEF = "invalid definition type for param arrsize"
_INVALID_PARAM_DESC_DEF = "invalid definition type for param desc"
_WARNING_MAP = {
    _EMPTY_YAML :
        "The yaml file list is empty.",
    _INVALID_YAML :
        "Invalid yaml file, error message: <<%s>>.",
    _DUPLICATE_DOMAIN :
        "Domain <<%s>> is already defined in <<%s>>.",
    _INVALID_DOMAIN_NUMBER :
        "The domain definition is missing in the yaml file.",
    _INVALID_DOMAIN_LENGTH :
        "The length of the domain must be between [1, 16], "\
        "but the actual length of the domain <<%s>> is <<%d>>.",
    _INVALID_DOMAIN_CHAR :
        "The character of the domain must be in [A-Z0-9_], "\
        "but the domain <<%s>> actually has <<%c>>.",
    _INVALID_DOMAIN_CHAR_HEAD :
        "The header of the domain must be in [A-Z], "\
        "but the actual header of the domain <<%s>> is <<%c>>.",
    _INVALID_EVENT_NUMBER :
        "The number of the events must be between [1, 4096], ."\
        "but there are actually <<%d>> events.",
    _INVALID_EVENT_LENGTH :
        "The length of the event must be between [1, 32], "\
        "but the actual length of the event <<%s>> is <<%d>>.",
    _INVALID_EVENT_CHAR :
        "The character of the event must be in [A-Z0-9_], "\
        "but the event <<%s>> actually has <<%c>>.",
    _INVALID_EVENT_CHAR_HEAD :
        "The header of the event must be in [A-Z], "\
        "but the actual header of the event <<%s>> is <<%c>>.",
    _MISSING_EVENT_BASE :
        "Event <<%s>> is missing __BASE definition.",
    _MISSING_EVENT_TYPE :
        "__BASE for event <<%s>> is missing type definition.",
    _INVALID_EVENT_TYPE :
        "The type of the event <<%s>> must be in "\
        "[FAULT, STATISTIC, SECURITY, BEHAVIOR], "\
        "but the actual event type is <<%s>>.",
    _MISSING_EVENT_LEVEL :
        "__BASE for event <<%s>> is missing level definition.",
    _INVALID_EVENT_LEVEL :
        "The level of the event <<%s>> must be in [CRITICAL, MINOR], "\
        "but the actual event level is <<%s>>.",
    _MISSING_EVENT_DESC :
        "__BASE for event <<%s>> is missing desc definition.",
    _INVALID_EVENT_DESC_LENGTH :
        "The length of the event desc must be between [3, 128], "\
        "but the actual length of the event <<%s>> desc <<%s>> is <<%d>>.",
    _INVALID_EVENT_TAG_NUM :
        "The number of the event tags must be between [0, 5], "\
        "but actually the event <<%s>> tag <<%s>> has <<%d>> tags.",
    _INVALID_EVENT_TAG_LEN :
        "The length of the event tag must be between [1, 16], "\
        "but the actual length of the event <<%s>> tag <<%s>> is <<%d>>.",
    _INVALID_EVENT_TAG_CHAR :
        "The character of the event tag must be in [A-Za-z0-9], "\
        "but the event <<%s>> tag <<%s>> actually has <<%c>>.",
    _DUPLICATE_EVENT_TAG :
        "Event tag should not be duplicated, "\
        "but tag <<%s>> for event <<%s>> has multiple identical.",
    _INVALID_EVENT_BASE_KEY :
        "Event <<%s>> __BASE key should be [type, level, tag, desc], "\
        "but actually has an invalid key <<%s>>.",
    _INVALID_EVENT_PARAM_NUM :
        "The number of the event param must be between [0, 128], "\
        "but actually the event <<%s>> has <<%d>> params.",
    _INVALID_EVENT_PARAM_LEN :
        "The length of the event param must be between [1, 32], "\
        "but the actual length of the event <<%s>> param <<%s>> is <<%d>>.",
    _INVALID_EVENT_PARAM_CHAR :
        "The character of the event param must be in [A-Z0-9_], "\
        "but the event <<%s>> param <<%s>> actually has <<%c>>.",
    _INVALID_EVENT_PARAM_CHAR_HEAD:
        "The header of the event param must be in [A-Z], "\
        "but the actual header of the event <<%s>> param <<%s>> is <<%c>>.",
    _MISSING_EVENT_PARAM_TYPE :
        "Event <<%s>> param <<%s>> is missing type definition.",
    _INVALID_EVENT_PARAM_TYPE :
        "The type of the event <<%s>> param <<%s>> must be in "\
        "[BOOL, INT8, UINT8, INT16, UINT16, INT32, UINT32, INT64, UINT64, "\
        "FLOAT, DOUBLE, STRING], but the actual type is <<%s>>.",
    _INVALID_EVENT_PARAM_ARRSIZE :
        "The arrsize of the event param must be between [1, 100], "\
        "but the actual arrsize of the event <<%s>> param <<%s>> is <<%d>>.",
    _MISSING_EVENT_PARAM_DESC :
        "Event <<%s>> param <<%s>> is missing desc definition.",
    _INVALID_EVENT_PARAM_DESC_LEN :
        "The length of the event param desc must be between [3, 128], "\
        "but the actual length of the event <<%s>> param <<%s>> "\
        "desc <<%s>> is <<%d>>.",
    _INVALID_EVENT_PARAM_KEY :
        "Event <<%s>> param <<%s>> key should be [type, arrsize, desc], "\
        "but actually has an invalid key <<%s>>.",
    _DEPRECATED_EVENT_NAME_PREFIX :
        "Event <<%s>> should not start with domain <<%s>>.",
    _DEPRECATED_PARAM_NAME_PREFIX :
        "Event param <<%s>> should not start with event <<%s>>.",
    _DEPRECATED_TAG_NAME :
        "Event tag <<%s>> should not be same as %s <<%s>>.",
    _DEPRECATED_EVENT_DESC_NAME :
        "Event desc <<%s>> should not be same as event <<%s>> and "\
        "should be more detailed.",
    _DEPRECATED_PARAM_DESC_NAME :
        "Event param desc <<%s>> should not be same as event <<%s>> "\
        "param <<%s>> and should be more detailed.",
    _INVALID_DOMAIN_DEF :
        "The definition type of the domain must be string.",
    _INVALID_EVENT_DEF :
        "The definition type of the event <<%s>> must be dictionary.",
    _INVALID_EVENT_BASE_DEF :
        "The definition type of the event <<%s>> __BASE must be dictionary.",
    _INVALID_EVENT_TYPE_DEF :
        "The definition type of the event <<%s>> type must be string.",
    _INVALID_EVENT_LEVEL_DEF :
        "The definition type of the event <<%s>> level must be string.",
    _INVALID_EVENT_DESC_DEF :
        "The definition type of the event <<%s>> desc must be string.",
    _INVALID_EVENT_TAG_DEF :
        "The definition type of the event <<%s>> tag must be string.",
    _INVALID_EVENT_PRESERVE_DEF :
        "The definition type of the event <<%s>> preserve must be bool.",
    _INVALID_EVENT_PARAM_DEF :
        "The definition type of the event <<%s>> param <<%s>> "\
        "must be dictionary.",
    _INVALID_PARAM_TYPE_DEF :
        "The definition type of the event <<%s>> param <<%s>> "\
        "type must be string.",
    _INVALID_PARAM_ARRSIZE_DEF :
        "The definition type of the event <<%s>> param <<%s>> "\
        "arrsize must be integer.",
    _INVALID_PARAM_DESC_DEF :
        "The definition type of the event <<%s>> param <<%s>> "\
        "desc must be string.",
    _DUPLICATE_KEY_DEF :
        "Duplicate key <<%s>> exists%s.",
}


_domain_dict = {}
_warning_dict = {}
_warning_file_path = ""
_yaml_file_path = ""
_warning_file = None
_hisysevent_parse_res = True
_deprecated_dict = {}


class _UniqueKeySafeLoader(yaml.SafeLoader):
    def construct_mapping(self, node, deep=False):
        mapping = []
        for key_node, value_node in node.value:
            key = self.construct_object(key_node, deep=deep)
            if (key in mapping):
                _build_warning_info(_DUPLICATE_KEY_DEF,
                    (key, key_node.start_mark))
                global _hisysevent_parse_res
                _hisysevent_parse_res = False
                continue
            mapping.append(key)
        return super().construct_mapping(node, deep)


def _build_header(info_dict: dict):
    table_header = "HiSysEvent yaml file: <<%s>>" % _yaml_file_path
    info_dict[_yaml_file_path] = [table_header]
    table_boundary = "-".rjust(100, '-')
    info_dict[_yaml_file_path].append(table_boundary)
    table_title = "Failed Item".ljust(50) + "|    " + "Failed Reason"
    info_dict[_yaml_file_path].append(table_title)
    info_dict[_yaml_file_path].append(table_boundary)


def _build_warning_header():
    global _warning_dict
    _build_header(_warning_dict)


def _build_deprecated_header():
    global _deprecated_dict
    _build_header(_deprecated_dict)


def _build_warning_info(item, values):
    detail = _WARNING_MAP[item] % values
    content = item.ljust(50) + "|    " + detail
    global _warning_dict
    _warning_dict[_yaml_file_path].append(content)


# Current set to warning, subsequent set to error.
def _build_deprecated_info(item, values):
    _build_deprecated_header()
    detail = _WARNING_MAP[item] % values
    content = item.ljust(50) + "|    " + detail
    global _deprecated_dict
    _deprecated_dict[_yaml_file_path].append(content)


def _open_warning_file(output_path: str):
    global _warning_file_path
    _warning_file_path = os.path.join(output_path, 'hisysevent_warning.txt')
    global _warning_file
    _warning_file = open(_warning_file_path, 'w+')


def _close_warning_file():
    if not _warning_file:
        _warning_file.close()


def _output_warning():
    for warning_list in _warning_dict.values():
        if len(warning_list) > 4 or len(warning_list) == 1:
            warning_list.append("")
            for content in warning_list:
                print(content)
                print(content, file=_warning_file)


def _output_deprecated(output_path: str):
    deprecated_file = open(os.path.join(output_path, 'hisysevent_deprecated.txt'), 'w+')
    for deprecated_list in _deprecated_dict.values():
        deprecated_list.append("")
        for content in deprecated_list:
            print(content, file=deprecated_file)
    if not deprecated_file:
        deprecated_file.close()


def _exit_sys():
    print("Failed to parse the yaml file. For details about the error "\
        "information, see file %s." % (_warning_file_path))
    _output_warning()
    _close_warning_file()
    sys.exit(1)


def _is_valid_length(content: str, len_min: int, len_max: int) -> bool:
    return len(content) >= len_min and len(content) <= len_max


def _is_valid_header(content: str) -> bool:
    return len(content) == 0 or (content[0] >= 'A' and content[0] <= 'Z')


def _is_invalid_char(ch) -> bool:
    return (ch >= 'A' and ch <= 'Z') or (ch >= '0' and ch <= '9') or ch == '_'


def _check_invalid_char(content: str):
    for ch in iter(content):
        if not _is_invalid_char(ch):
            return ch
    return None


def _check_domain_duplicate(domain: str) -> bool:
    if domain in _domain_dict:
        _build_warning_info(_DUPLICATE_DOMAIN, (domain, _domain_dict[domain]))
        return False
    else:
        _domain_dict[domain] = _yaml_file_path
        return True


def _check_event_domain(yaml_info: dict) -> bool:
    if not "domain" in yaml_info:
        _build_warning_info(_INVALID_DOMAIN_NUMBER, ())
        return False
    if not isinstance(yaml_info["domain"], str):
        _build_warning_info(_INVALID_DOMAIN_DEF, ())
        return False
    domain = yaml_info["domain"]
    check_res = True
    if not _is_valid_length(domain, 1, 16):
        _build_warning_info(_INVALID_DOMAIN_LENGTH, (domain, len(domain)))
        check_res = False
    if not _is_valid_header(domain):
        _build_warning_info(_INVALID_DOMAIN_CHAR_HEAD, (domain, domain[0]))
        check_res = False
    invalid_ch = _check_invalid_char(domain)
    if invalid_ch:
        _build_warning_info(_INVALID_DOMAIN_CHAR, (domain, invalid_ch))
        check_res = False
    if not _check_domain_duplicate(domain):
        check_res = False
    return check_res


def _check_yaml_format(yaml_info) -> bool:
    if not yaml_info:
        _build_warning_info(_INVALID_YAML, ("The yaml file is empty"))
        return False
    if not isinstance(yaml_info, dict):
        _build_warning_info(_INVALID_YAML,
            ("The content of yaml file is invalid"))
        return False
    return True


def _check_event_name(domain: str, event_name: str) -> bool:
    check_res = True
    if not _is_valid_length(event_name, 1, 32):
        _build_warning_info(_INVALID_EVENT_LENGTH,
            (event_name, len(event_name)))
        check_res = False
    if len(domain) > 0 and event_name.startswith(domain):
        _build_deprecated_info(_DEPRECATED_EVENT_NAME_PREFIX,
            (event_name, domain))
    if not _is_valid_header(event_name):
        _build_warning_info(_INVALID_EVENT_CHAR_HEAD,
            (event_name, event_name[0]))
        check_res = False
    invalid_ch = _check_invalid_char(event_name)
    if invalid_ch:
        _build_warning_info(_INVALID_DOMAIN_CHAR, (event_name, invalid_ch))
        check_res = False
    return check_res


def _check_event_type(event_name: str, event_base: dict) -> bool:
    if not "type" in event_base:
        _build_warning_info(_MISSING_EVENT_TYPE, (event_name))
        return False
    else:
        if not isinstance(event_base["type"], str):
            _build_warning_info(_INVALID_EVENT_TYPE_DEF, event_name)
            return False
        type_list = ["FAULT", "STATISTIC", "SECURITY", "BEHAVIOR"]
        if not event_base["type"] in type_list:
            _build_warning_info(_INVALID_EVENT_TYPE,
                (event_name, event_base["type"]))
            return False
    return True


def _check_event_level(event_name: str, event_base: dict) -> bool:
    if not "level" in event_base:
        _build_warning_info(_MISSING_EVENT_LEVEL, (event_name))
        return False
    else:
        if not isinstance(event_base["level"], str):
            _build_warning_info(_INVALID_EVENT_LEVEL_DEF, event_name)
            return False
        level_list = ["CRITICAL", "MINOR"]
        if not event_base["level"] in level_list:
            _build_warning_info(_INVALID_EVENT_LEVEL,
                (event_name, event_base["level"]))
            return False
    return True


def _check_event_desc(event_name: str, event_base: dict) -> bool:
    if not "desc" in event_base:
        _build_warning_info(_MISSING_EVENT_DESC, (event_name))
        return False
    else:
        event_desc = event_base["desc"]
        if not isinstance(event_desc, str):
            _build_warning_info(_INVALID_EVENT_DESC_DEF, event_name)
            return False
        check_res = True
        if event_desc.lower() == event_name.lower():
            _build_deprecated_info(_DEPRECATED_EVENT_DESC_NAME,
                (event_desc, event_name))
        if not _is_valid_length(event_desc, 3, 128):
            _build_warning_info(_INVALID_EVENT_DESC_LENGTH,
                (event_name, event_desc, len(event_desc)))
            check_res = False
        return check_res


def _check_tag_char(event_tag: list):
    for ch in iter(event_tag):
        if not ch.isalnum():
            return ch
    return None


def _check_tag_name(event_name: str, event_base: dict, tag_name: str) -> bool:
    check_res = True
    if tag_name.lower() == event_name.lower():
        _build_deprecated_info(_DEPRECATED_TAG_NAME,
            (tag_name, "event", event_name))
    if "type" in event_base and tag_name.lower() == event_base["type"].lower():
        _build_deprecated_info(_DEPRECATED_TAG_NAME,
            (tag_name, "event type", event_base["type"]))
    if not _is_valid_length(tag_name, 1, 16):
        _build_warning_info(_INVALID_EVENT_TAG_LEN,
            (event_name, tag_name, len(tag_name)))
        check_res = False
    invalid_ch = _check_tag_char(tag_name)
    if invalid_ch:
        _build_warning_info(_INVALID_EVENT_TAG_CHAR,
            (event_name, tag_name, invalid_ch))
        check_res = False
    return check_res


def _get_duplicate_tag(tag_list: list):
    tag_dict = dict(Counter(tag_list))
    for key, value in tag_dict.items():
        if value > 1:
            return key
    return None


def _check_event_tag(event_name: str, event_base: dict) -> bool:
    if not "tag" in event_base:
        return True
    event_tag = event_base["tag"]
    if not isinstance(event_tag, str):
        _build_warning_info(_INVALID_EVENT_TAG_DEF, event_name)
        return False
    tag_list = event_tag.split()
    if not _is_valid_length(tag_list, 1, 5):
        _build_warning_info(_INVALID_EVENT_TAG_NUM,
            (event_name, event_tag, len(tag_list)))
        return False
    check_res = True
    for each_tag in tag_list:
        if not _check_tag_name(event_name, event_base, each_tag):
            check_res = False
    dup_tag = _get_duplicate_tag(tag_list)
    if dup_tag:
        _build_warning_info(_DUPLICATE_EVENT_TAG, (dup_tag, event_name))
        check_res = False
    return check_res


def _check_event_preserve(event_name: str, event_base: dict) -> bool:
    if not "preserve" in event_base:
        return True
    event_preserve = event_base["preserve"]
    if not isinstance(event_preserve, bool):
        _build_warning_info(_INVALID_EVENT_PRESERVE_DEF, event_name)
        return False
    return True


def _check_base_key(event_name: str, event_base: dict) -> bool:
    key_list = ["type", "level", "tag", "desc", "preserve"]
    for base_key in event_base.keys():
        if not base_key in key_list:
            _build_warning_info(_INVALID_EVENT_BASE_KEY,
                (event_name, base_key))
            return False
    return True


def _check_event_base(event_name: str, event_def: str) -> bool:
    if not "__BASE" in event_def:
        _build_warning_info(_MISSING_EVENT_BASE, (event_name))
        return False
    event_base = event_def["__BASE"]
    if not isinstance(event_base, dict):
        _build_warning_info(_INVALID_EVENT_BASE_DEF, (event_name))
        return False
    check_res = True
    if not _check_event_type(event_name, event_base):
        check_res = False
    if not _check_event_level(event_name, event_base):
        check_res = False
    if not _check_event_desc(event_name, event_base):
        check_res = False
    if not _check_event_tag(event_name, event_base):
        check_res = False
    if not _check_event_preserve(event_name, event_base):
        check_res = False
    if not _check_base_key(event_name, event_base):
        check_res = False
    return check_res


def _check_param_name(event_name: str, name: str) -> bool:
    check_res = True
    if not _is_valid_length(name, 1, 32):
        _build_warning_info(_INVALID_EVENT_PARAM_LEN,
            (event_name, name, len(name)))
        check_res = False
    if len(event_name) > 0 and name.startswith(event_name):
        _build_deprecated_info(_DEPRECATED_PARAM_NAME_PREFIX, (name, event_name))
    if not _is_valid_header(name):
        _build_warning_info(_INVALID_EVENT_PARAM_CHAR_HEAD,
            (event_name, name, name[0]))
        check_res = False
    invalid_ch = _check_invalid_char(name)
    if invalid_ch:
        _build_warning_info(_INVALID_EVENT_PARAM_CHAR,
            (event_name, name, invalid_ch))
        check_res = False
    return check_res


def _check_param_type(event_name: str, param_name: str, param_info: dict) -> bool:
    if not "type" in param_info:
        _build_warning_info(_MISSING_EVENT_PARAM_TYPE,
            (event_name, param_name))
        return False
    else:
        if not isinstance(param_info["type"], str):
            _build_warning_info(_INVALID_PARAM_TYPE_DEF,
                (event_name, param_name))
            return False
        type_list = ["BOOL", "INT8", "UINT8", "INT16", "UINT16", "INT32",
            "UINT32", "INT64", "UINT64", "FLOAT", "DOUBLE", "STRING"]
        if not param_info["type"] in type_list:
            _build_warning_info(_INVALID_EVENT_PARAM_TYPE,
                (event_name, param_name, param_info["type"]))
            return False
    return True


def _check_param_arrsize(event_name: str, param_name: str, param_info: dict) -> bool:
    if not "arrsize" in param_info:
        return True
    arrsize = param_info["arrsize"]
    if not isinstance(arrsize, int):
        _build_warning_info(_INVALID_PARAM_ARRSIZE_DEF,
            (event_name, param_name))
        return False
    if not (arrsize >= 1 and arrsize <= 100):
        _build_warning_info(_INVALID_EVENT_PARAM_ARRSIZE,
            (event_name, param_name, arrsize))
        return False
    return True


def _check_param_desc(event_name: str, param_name: str, param_info: dict) -> bool:
    if not "desc" in param_info:
        _build_warning_info(_MISSING_EVENT_PARAM_DESC,
            (event_name, param_name))
        return False
    else:
        param_desc = param_info["desc"]
        if not isinstance(param_desc, str):
            _build_warning_info(_INVALID_PARAM_DESC_DEF,
                (event_name, param_name))
            return False
        check_res = True
        if param_desc.lower() == param_name.lower():
            _build_deprecated_info(_DEPRECATED_PARAM_DESC_NAME,
                (param_desc, event_name, param_name))
        if not _is_valid_length(param_desc, 3, 128):
            _build_warning_info(_INVALID_EVENT_PARAM_DESC_LEN,
                (event_name, param_name, param_desc, len(param_desc)))
            check_res = False
        return check_res


def _check_param_key(event_name: str, param_name: str, param_info: dict) -> bool:
    key_list = ["type", "arrsize", "desc"]
    for key in param_info.keys():
        if not key in key_list:
            _build_warning_info(_INVALID_EVENT_PARAM_KEY,
                (event_name, param_name, key))
            return False
    return True


def _check_param_info(event_name: str, param_name: str, param_info: dict) -> bool:
    check_res = True
    if not _check_param_type(event_name, param_name, param_info):
        check_res = False
    if not _check_param_arrsize(event_name, param_name, param_info):
        check_res = False
    if not _check_param_desc(event_name, param_name, param_info):
        check_res = False
    if not _check_param_key(event_name, param_name, param_info):
        check_res = False
    return check_res


def _check_event_param(event_name: str, event_def: str) -> bool:
    sub_num = (0, 1)["__BASE" in event_def]
    check_res = True
    if not _is_valid_length(event_def, 0 + sub_num, 128 + sub_num):
        _build_warning_info(_INVALID_EVENT_PARAM_NUM,
            (event_name, (len(event_def) - sub_num)))
        check_res = False
    for param_name in event_def.keys():
        if param_name == "__BASE":
            continue
        if not _check_param_name(event_name, param_name):
            check_res = False
        param_info = event_def[param_name]
        if not isinstance(param_info, dict):
            _build_warning_info(_INVALID_EVENT_PARAM_DEF,
                (event_name, param_name))
            check_res = False
            continue
        if not _check_param_info(event_name, param_name, param_info):
            check_res = False
    return check_res


def _check_event_def(event_name: str, event_def: str) -> bool:
    check_res = True
    if not _check_event_base(event_name, event_def):
        check_res = False
    if not _check_event_param(event_name, event_def):
        check_res = False
    return check_res


def _check_event_info(domain: str, event_info: list) -> bool:
    event_name = event_info[0]
    event_def = event_info[1]
    check_res = True
    if not isinstance(event_def, dict):
        _build_warning_info(_INVALID_EVENT_DEF, (event_name))
        return False
    if not _check_event_name(domain, event_name):
        check_res = False
    if not _check_event_def(event_name, event_def):
        check_res = False
    return check_res


def _check_events_info(domain: str, yaml_info: str) -> bool:
    event_num = len(yaml_info)
    if not (event_num >= 1 and event_num <= 4096):
        _build_warning_info(_INVALID_EVENT_NUMBER, (event_num))
        return False
    check_res = True
    for event_info in yaml_info.items():
        if not _check_event_info(domain, event_info):
            check_res = False
    return check_res


def merge_hisysevent_config(yaml_list: str, output_path: str) -> str:
    if (len(output_path) == 0):
        present_path = os.path.dirname(os.path.abspath(__file__))
        output_path = present_path
    if (len(yaml_list) == 0):
        _build_warning_info(_EMPTY_YAML, ())
        _exit_sys()
    if not os.path.exists(output_path):
        os.makedirs(output_path, exist_ok=True)
    _open_warning_file(output_path)

    yaml_info_dict = {}
    global _hisysevent_parse_res
    for yaml_path in yaml_list:
        global _yaml_file_path
        _yaml_file_path = yaml_path.replace("../", "")
        _build_warning_header()
        with os.fdopen(os.open(yaml_path, os.O_RDWR | os.O_CREAT, stat.S_IWUSR | stat.S_IRUSR),
            'r', encoding='utf-8') as yaml_file:
            yaml_info = yaml.load(yaml_file, Loader=_UniqueKeySafeLoader)
        if not _check_yaml_format(yaml_info):
            _hisysevent_parse_res = False
            continue
        if not _check_event_domain(yaml_info):
            _hisysevent_parse_res = False
            continue
        domain = yaml_info["domain"]
        del yaml_info["domain"]
        if not _check_events_info(domain, yaml_info):
            _hisysevent_parse_res = False
            continue
        yaml_info_dict[domain] = yaml_info
    _output_deprecated(output_path)
    if not _hisysevent_parse_res:
        _exit_sys()

    hisysevent_def_file = os.path.join(output_path, 'hisysevent.def')
    with open(hisysevent_def_file, 'w') as j:
        json.dump(yaml_info_dict, j, indent=4)
    print("The hisysevent.def {} is generated successfully."
        .format(hisysevent_def_file))
    _close_warning_file()

    # zip def file
    hisysevent_def_zip_file = os.path.join(output_path, 'hisysevent.zip')
    def_zip_file = zipfile.ZipFile(hisysevent_def_zip_file, "w", zipfile.ZIP_DEFLATED)
    def_zip_file.write(hisysevent_def_file, arcname=os.path.basename(hisysevent_def_file))
    def_zip_file.close()
    # remove def file
    os.remove(hisysevent_def_file)

    return hisysevent_def_zip_file


def main(argv) -> int:
    parser = argparse.ArgumentParser(description='yaml list')
    parser.add_argument("--yaml-list", nargs='+', required=True)
    parser.add_argument("--def-path", required=True)
    args = parser.parse_args(argv)
    hisysevent_def_file = merge_hisysevent_config(args.yaml_list,
        args.def_path)
    print(hisysevent_def_file)
    return 0


if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))