From cca4dc0c544a4517a4863f9990baa5cbd72275e5 Mon Sep 17 00:00:00 2001 From: Shuicheng Lin Date: Tue, 19 Feb 2019 19:23:19 +0800 Subject: [PATCH] Implement FaultAPIsV2 to distinguish fail and no data case Current FaultAPIs (get_fault/get_faults/get_faults_by_id) cannot distinguish error and no data case. None will be returned for both case. To separate these two cases, and implement the code more as pythonic way, FaultAPIsV2 is added, which will raise exception for error case. In order to separate the cases, the C functions called by API are modified to return FALSE for error, and return None for no data. Test: Pass basic deploy test, and "fm alarm-*" cmd work as before. Use fm_api_test.py/fm_api_v2_test.py to manual trigger API call, confirm alarm could be created/get/deleted, and value is the same as "fm alarm-list". Modify fmManager to simulate error case, confirm exception is generated for FaultAPIsV2, and behavior is not changed for FaultAPIs. Story: 2004859 Task: 29097 Change-Id: Ic1c0a15eb8dfec6c368099b096d6a158da0d3c77 Signed-off-by: Shuicheng Lin --- fm-api/centos/build_srpm.data | 2 +- fm-api/fm_api/fm_api.py | 187 +++++++++++++++-------- fm-api/fm_api_test.py | 32 ++-- fm-api/fm_api_v2_test.py | 125 +++++++++++++++ fm-common/sources/fm_python_mod_main.cpp | 21 +-- 5 files changed, 279 insertions(+), 88 deletions(-) create mode 100644 fm-api/fm_api_v2_test.py diff --git a/fm-api/centos/build_srpm.data b/fm-api/centos/build_srpm.data index c5375f07..cf6e9ddb 100755 --- a/fm-api/centos/build_srpm.data +++ b/fm-api/centos/build_srpm.data @@ -2,4 +2,4 @@ SRC_DIR="." COPY_LIST="$PKG_BASE/LICENSE" EXCLUDE_FILES_FROM_TAR="centos" -TIS_PATCH_VER=13 +TIS_PATCH_VER=14 diff --git a/fm-api/fm_api/fm_api.py b/fm-api/fm_api/fm_api.py index 321fd267..e69231b2 100755 --- a/fm-api/fm_api/fm_api.py +++ b/fm-api/fm_api/fm_api.py @@ -20,6 +20,10 @@ class ClientException(Exception): pass +class APIException(Exception): + pass + + # Fields explanation: # # alarm_id: a text string of the alarm identifier @@ -70,66 +74,7 @@ class Fault(object): return value -class FaultAPIs(object): - - def set_fault(self, data): - self._check_required_attributes(data) - self._validate_attributes(data) - buff = self._alarm_to_str(data) - try: - return fm_core.set(buff) - except (RuntimeError, SystemError, TypeError): - return None - - def clear_fault(self, alarm_id, entity_instance_id): - sep = constants.FM_CLIENT_STR_SEP - buff = (sep + self._check_val(alarm_id) + sep + - self._check_val(entity_instance_id) + sep) - try: - return fm_core.clear(buff) - except (RuntimeError, SystemError, TypeError): - return False - - def get_fault(self, alarm_id, entity_instance_id): - sep = constants.FM_CLIENT_STR_SEP - buff = (sep + self._check_val(alarm_id) + sep + - self._check_val(entity_instance_id) + sep) - try: - resp = fm_core.get(buff) - return self._str_to_alarm(resp) if resp else None - except (RuntimeError, SystemError, TypeError): - return None - - def clear_all(self, entity_instance_id): - try: - return fm_core.clear_all(entity_instance_id) - except (RuntimeError, SystemError, TypeError): - return False - - def get_faults(self, entity_instance_id): - try: - resp = fm_core.get_by_eid(entity_instance_id) - if resp is not None: - data = [] - for i in resp: - data.append(self._str_to_alarm(i)) - return data - except (RuntimeError, SystemError, TypeError): - pass - return None - - def get_faults_by_id(self, alarm_id): - try: - resp = fm_core.get_by_aid(alarm_id) - if resp is not None: - data = [] - for i in resp: - data.append(self._str_to_alarm(i)) - return data - except (RuntimeError, SystemError, TypeError): - pass - return None - +class FaultAPIsBase(object): @staticmethod def _check_val(data): if data is None: @@ -222,3 +167,125 @@ class FaultAPIs(object): if given < threshold: return True return False + + +class FaultAPIs(FaultAPIsBase): + + def set_fault(self, data): + self._check_required_attributes(data) + self._validate_attributes(data) + buff = self._alarm_to_str(data) + try: + return fm_core.set(buff) + except (RuntimeError, SystemError, TypeError): + return None + + def clear_fault(self, alarm_id, entity_instance_id): + sep = constants.FM_CLIENT_STR_SEP + buff = (sep + self._check_val(alarm_id) + sep + + self._check_val(entity_instance_id) + sep) + try: + return fm_core.clear(buff) + except (RuntimeError, SystemError, TypeError): + return False + + def get_fault(self, alarm_id, entity_instance_id): + sep = constants.FM_CLIENT_STR_SEP + buff = (sep + self._check_val(alarm_id) + sep + + self._check_val(entity_instance_id) + sep) + try: + resp = fm_core.get(buff) + if resp: + return self._str_to_alarm(resp) + except (RuntimeError, SystemError, TypeError): + pass + return None + + def clear_all(self, entity_instance_id): + try: + return fm_core.clear_all(entity_instance_id) + except (RuntimeError, SystemError, TypeError): + return False + + def get_faults(self, entity_instance_id): + try: + resp = fm_core.get_by_eid(entity_instance_id) + if resp: + data = [] + for i in resp: + data.append(self._str_to_alarm(i)) + return data + except (RuntimeError, SystemError, TypeError): + pass + return None + + def get_faults_by_id(self, alarm_id): + try: + resp = fm_core.get_by_aid(alarm_id) + if resp: + data = [] + for i in resp: + data.append(self._str_to_alarm(i)) + return data + except (RuntimeError, SystemError, TypeError): + pass + return None + + +class FaultAPIsV2(FaultAPIsBase): + + def set_fault(self, data): + self._check_required_attributes(data) + self._validate_attributes(data) + buff = self._alarm_to_str(data) + uuid = fm_core.set(buff) + if uuid is None: + raise APIException("Failed to execute set_fault.") + return uuid + + def clear_fault(self, alarm_id, entity_instance_id): + sep = constants.FM_CLIENT_STR_SEP + buff = (sep + self._check_val(alarm_id) + sep + + self._check_val(entity_instance_id) + sep) + resp = fm_core.clear(buff) + if resp is False: + raise APIException("Failed to execute clear_fault.") + + def get_fault(self, alarm_id, entity_instance_id): + sep = constants.FM_CLIENT_STR_SEP + buff = (sep + self._check_val(alarm_id) + sep + + self._check_val(entity_instance_id) + sep) + resp = fm_core.get(buff) + if resp is False: + raise APIException("Failed to execute get_fault.") + else: + return self._str_to_alarm(resp) if resp else None + + def clear_all(self, entity_instance_id): + resp = fm_core.clear_all(entity_instance_id) + if resp is False: + raise APIException("Failed to execute clear_all.") + + def get_faults(self, entity_instance_id): + resp = fm_core.get_by_eid(entity_instance_id) + if resp is False: + raise APIException("Failed to execute get_faults.") + elif resp: + data = [] + for i in resp: + data.append(self._str_to_alarm(i)) + return data + else: + return None + + def get_faults_by_id(self, alarm_id): + resp = fm_core.get_by_aid(alarm_id) + if resp is False: + raise APIException("Failed to execute get_faults_by_id.") + elif resp: + data = [] + for i in resp: + data.append(self._str_to_alarm(i)) + return data + else: + return None diff --git a/fm-api/fm_api_test.py b/fm-api/fm_api_test.py index e3a18451..a63c9dfa 100644 --- a/fm-api/fm_api_test.py +++ b/fm-api/fm_api_test.py @@ -17,9 +17,11 @@ # under the License. import sys -from fm_api import Fault, FaultAPIs +from fm_api import fm_api from fm_api import constants +ser = fm_api.FaultAPIs() + def print_alarm(alarm): alarm_str = "alarm_id: " + alarm.alarm_id + ", " @@ -35,36 +37,32 @@ def print_alarm(alarm): def create(): - ser = FaultAPIs() - fault = Fault(alarm_id=constants.FM_ALARM_ID_VM_RESCUED, - alarm_state=constants.FM_ALARM_STATE_SET, - entity_type_id=constants.FM_ENTITY_TYPE_INSTANCE, - entity_instance_id=constants.FM_ENTITY_TYPE_INSTANCE + '=' + 'a4e4cdb7-2ee6-4818-84c8-5310fcd67b5d', - severity=constants.FM_ALARM_SEVERITY_CRITICAL, - reason_text="Unknown", - alarm_type=constants.FM_ALARM_TYPE_5, - probable_cause=constants.ALARM_PROBABLE_CAUSE_8, - proposed_repair_action=None, - service_affecting=False, - suppression=False) + fault = fm_api.Fault(alarm_id=constants.FM_ALARM_ID_VM_FAILED, + alarm_state=constants.FM_ALARM_STATE_SET, + entity_type_id=constants.FM_ENTITY_TYPE_INSTANCE, + entity_instance_id=constants.FM_ENTITY_TYPE_INSTANCE + '=' + 'a4e4cdb7-2ee6-4818-84c8-5310fcd67b5d', + severity=constants.FM_ALARM_SEVERITY_CRITICAL, + reason_text="Unknown", + alarm_type=constants.FM_ALARM_TYPE_5, + probable_cause=constants.ALARM_PROBABLE_CAUSE_8, + proposed_repair_action=None, + service_affecting=False, + suppression=False) uuid = ser.set_fault(fault) print(uuid) def delete(alarm_id, instance_id): - ser = FaultAPIs() ret = ser.clear_fault(alarm_id, instance_id) print("Delete fault return %s" % str(ret)) def del_all(instance_id): - ser = FaultAPIs() ret = ser.clear_all(instance_id) print("Delete faults return: %s" % str(ret)) def get(alarm_id, instance_id): - ser = FaultAPIs() a = ser.get_fault(alarm_id, instance_id) if a is not None: print_alarm(a) @@ -73,7 +71,6 @@ def get(alarm_id, instance_id): def get_all(instance_id): - ser = FaultAPIs() ll = ser.get_faults(instance_id) if ll is not None: print("Total alarm returned: %d\n" @@ -85,7 +82,6 @@ def get_all(instance_id): def get_list(alarm_id): - ser = FaultAPIs() ll = ser.get_faults_by_id(alarm_id) if ll is not None: print("Total alarm returned: %d\n" diff --git a/fm-api/fm_api_v2_test.py b/fm-api/fm_api_v2_test.py new file mode 100644 index 00000000..1e1df3cd --- /dev/null +++ b/fm-api/fm_api_v2_test.py @@ -0,0 +1,125 @@ +# -*- encoding: utf-8 -*- +# +# Copyright (c) 2014 Wind River Systems, Inc. +# +# Author: +# +# 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 +from fm_api import fm_api +from fm_api import constants + +ser = fm_api.FaultAPIsV2() + + +def print_alarm(alarm): + alarm_str = "alarm_id: " + alarm.alarm_id + ", " + alarm_str += "uuid: " + alarm.uuid + ", " + alarm_str += "alarm_type: " + alarm.alarm_type + "\n" + alarm_str += "state: " + alarm.alarm_state + ", " + alarm_str += "severity: " + alarm.severity + ", " + alarm_str += "entity_type_id: " + alarm.entity_type_id + ", " + alarm_str += "timestamp: " + alarm.timestamp + "\n" + alarm_str += "entity_instance_id: " + alarm.entity_instance_id + ", " + alarm_str += "probable cause:" + alarm.probable_cause + "\n" + print(alarm_str) + + +def create(): + fault = fm_api.Fault(alarm_id=constants.FM_ALARM_ID_VM_FAILED, + alarm_state=constants.FM_ALARM_STATE_SET, + entity_type_id=constants.FM_ENTITY_TYPE_INSTANCE, + entity_instance_id=constants.FM_ENTITY_TYPE_INSTANCE + '=' + 'a4e4cdb7-2ee6-4818-84c8-5310fcd67b5d', + severity=constants.FM_ALARM_SEVERITY_CRITICAL, + reason_text="Unknown", + alarm_type=constants.FM_ALARM_TYPE_5, + probable_cause=constants.ALARM_PROBABLE_CAUSE_8, + proposed_repair_action=None, + service_affecting=False, + suppression=False) + try: + uuid = ser.set_fault(fault) + print(uuid) + except Exception: + print("Fail to create fault") + + +def delete(alarm_id, instance_id): + try: + ser.clear_fault(alarm_id, instance_id) + print("Delete fault success") + except Exception: + print("Fail to delete fault") + + +def del_all(instance_id): + try: + ser.clear_all(instance_id) + print("Delete faults success") + except Exception: + print("Fail to delete faults") + + +def get(alarm_id, instance_id): + try: + a = ser.get_fault(alarm_id, instance_id) + if a is not None: + print_alarm(a) + else: + print("Alarm not found") + except Exception: + print("Fail to get alarm") + + +def get_all(instance_id): + try: + ll = ser.get_faults(instance_id) + if ll is not None: + print("Total alarm returned: %d\n" + % len(ll)) + for i in ll: + print_alarm(i) + else: + print("No alarm returned") + except Exception: + print("Fail to get alarm") + + +def get_list(alarm_id): + try: + ll = ser.get_faults_by_id(alarm_id) + if ll is not None: + print("Total alarm returned: %d\n" + % len(ll)) + for i in ll: + print_alarm(i) + else: + print("No alarm returned") + except Exception: + print("Fail to get alarm") + + +if __name__ == "__main__": + if sys.argv[1] == "create": + sys.exit(create()) + elif sys.argv[1] == "del": + sys.exit(delete(sys.argv[2], sys.argv[3])) + elif sys.argv[1] == "get": + sys.exit(get(sys.argv[2], sys.argv[3])) + elif sys.argv[1] == "get_all": + sys.exit(get_all(sys.argv[2])) + elif sys.argv[1] == "del_all": + sys.exit(del_all(sys.argv[2])) + elif sys.argv[1] == "get_list": + sys.exit(get_list(sys.argv[2])) diff --git a/fm-common/sources/fm_python_mod_main.cpp b/fm-common/sources/fm_python_mod_main.cpp index acfc0769..e1891208 100644 --- a/fm-common/sources/fm_python_mod_main.cpp +++ b/fm-common/sources/fm_python_mod_main.cpp @@ -108,13 +108,13 @@ static PyObject * _fm_get(PyObject * self, PyObject *args) { if (!PyArg_ParseTuple(args, "s", &filter)) { ERROR_LOG("Failed to parse args"); - Py_RETURN_NONE; + Py_RETURN_FALSE; } filter_str.assign(filter); if (!fm_alarm_filter_from_string(filter_str, &af)) { ERROR_LOG("Invalid alarm filter: (%s)", filter_str.c_str()); - Py_RETURN_NONE; + Py_RETURN_FALSE; } rc = fm_get_fault(&af,&ad); @@ -126,13 +126,14 @@ static PyObject * _fm_get(PyObject * self, PyObject *args) { if (rc == FM_ERR_ENTITY_NOT_FOUND) { DEBUG_LOG("Alarm id (%s), Entity id:(%s) not found", af.alarm_id, af.entity_instance_id); + Py_RETURN_NONE; } else if (rc == FM_ERR_NOCONNECT) { WARNING_LOG("Failed to connect to FM manager"); } else { ERROR_LOG("Failed to get alarm by filter: (%s) (%s), error code: (%d)", af.alarm_id, af.entity_instance_id, rc); } - Py_RETURN_NONE; + Py_RETURN_FALSE; } @@ -145,7 +146,7 @@ static PyObject * _fm_get_by_aid(PyObject * self, PyObject *args, PyObject* kwar memset(alm_id, 0 , sizeof(alm_id)); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|i", keywords, &aid, &max)) { ERROR_LOG("Failed to parse args"); - Py_RETURN_NONE; + Py_RETURN_FALSE; } strncpy(alm_id, aid, sizeof(alm_id)-1); @@ -154,7 +155,7 @@ static PyObject * _fm_get_by_aid(PyObject * self, PyObject *args, PyObject* kwar lst.resize(max); } catch(...) { ERROR_LOG("Failed to allocate memory"); - Py_RETURN_NONE; + Py_RETURN_FALSE; } unsigned int max_alarms_to_get = max; EFmErrorT rc = fm_get_faults_by_id(&alm_id, &(lst[0]), &max_alarms_to_get); @@ -176,12 +177,13 @@ static PyObject * _fm_get_by_aid(PyObject * self, PyObject *args, PyObject* kwar if (rc == FM_ERR_ENTITY_NOT_FOUND) { DEBUG_LOG("No alarm found for alarm id (%s)", alm_id); + Py_RETURN_NONE; } else if (rc == FM_ERR_NOCONNECT) { WARNING_LOG("Failed to connect to FM manager"); } else { ERROR_LOG("Failed to get alarm list for alarm id (%s), error code: (%d)", alm_id, rc); } - Py_RETURN_NONE; + Py_RETURN_FALSE; } static PyObject * _fm_get_by_eid(PyObject * self, PyObject *args, PyObject* kwargs) { @@ -194,7 +196,7 @@ static PyObject * _fm_get_by_eid(PyObject * self, PyObject *args, PyObject* kwar memset(inst_id, 0 , sizeof(inst_id)); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|i", keywords, &eid, &max)) { ERROR_LOG("Failed to parse args"); - Py_RETURN_NONE; + Py_RETURN_FALSE; } strncpy(inst_id, eid ,sizeof(inst_id)-1); @@ -202,7 +204,7 @@ static PyObject * _fm_get_by_eid(PyObject * self, PyObject *args, PyObject* kwar lst.resize(max); } catch(...) { ERROR_LOG("Failed to allocate memory"); - Py_RETURN_NONE; + Py_RETURN_FALSE; } unsigned int max_alarms_to_get = max; EFmErrorT rc = fm_get_faults(&inst_id, &(lst[0]), &max_alarms_to_get); @@ -224,12 +226,13 @@ static PyObject * _fm_get_by_eid(PyObject * self, PyObject *args, PyObject* kwar if (rc == FM_ERR_ENTITY_NOT_FOUND) { DEBUG_LOG("No alarm found for entity id (%s)", inst_id); + Py_RETURN_NONE; } else if (rc == FM_ERR_NOCONNECT) { WARNING_LOG("Failed to connect to FM manager"); } else { ERROR_LOG("Failed to get alarm list for entity id (%s), error code: (%d)", inst_id, rc); } - Py_RETURN_NONE; + Py_RETURN_FALSE; } static PyObject * _fm_clear(PyObject * self, PyObject *args) {