fault/fm-common/sources/fm_cli.cpp

//
// Copyright (c) 2014 Wind River Systems, Inc.
//
// SPDX-License-Identifier: Apache-2.0
//

#include "fmAPI.h"
#include "fmAlarmUtils.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <string>

void error(const char *add="") {
	printf("%s\n",add);
	exit(-1);
}

void ok(const char *s="") {
	printf("Ok\n%s%s",s,strlen(s)!=0 ? "\n":"");
	exit(0);
}

void ok(fm_uuid_t *uuid) {
	return ok(*uuid);
}

void create_alarm(const char *al) {
	SFmAlarmDataT alarm;
	EFmErrorT rc;

	memset(&alarm,0,sizeof(alarm));

	if (!fm_alarm_from_string(al,&alarm)) {
		error("Invalid alarm string..");
	}

	//clear uuid and let it be set by fm-mgr
	memset(alarm.uuid, 0, sizeof(*alarm.uuid));
	fm_uuid_t uuid;
	if ((rc = fm_set_fault(&alarm,&uuid))!=FM_ERR_OK) {
		std::string errstr = fm_error_from_int(rc);
		error(errstr.c_str());
	}
	ok(&uuid);
}

void delete_alarms(const char *id) {
	fm_ent_inst_t inst_id;
	EFmErrorT rc;

	memset(inst_id, 0 , sizeof(inst_id));
	strncpy(inst_id, id ,sizeof(inst_id)-1);

	if ((rc = fm_clear_all(&inst_id))!=FM_ERR_OK) {
		std::string errstr = fm_error_from_int(rc);
		error(errstr.c_str());
	}
	ok();
}

void delete_alarm(const char *f) {
	AlarmFilter af;
	EFmErrorT rc;

	memset(&af,0,sizeof(af));
	if (!fm_alarm_filter_from_string(f,&af)) {
		error("Invalid alarm filter");
	}
	if ((rc = fm_clear_fault(&af))!=FM_ERR_OK) {
		std::string errstr = fm_error_from_int(rc);
		error(errstr.c_str());
	}
	ok();
}

void get_alarm(const char *f) {
	AlarmFilter af;
	EFmErrorT rc;

	memset(&af, 0, sizeof(af));
	if (!fm_alarm_filter_from_string(f,&af)) {
		error("Invalid alarm filter");
	}

	SFmAlarmDataT ad;
	memset(&ad, 0 , sizeof(ad));

	if ((rc = fm_get_fault(&af,&ad))!=FM_ERR_OK) {
		std::string errstr = fm_error_from_int(rc);
		error(errstr.c_str());
	}
	std::string s;
	fm_alarm_to_string(&ad,s);
	ok(s.c_str());
}

void get_alarms(const char *id) {
	fm_ent_inst_t inst_id;
	EFmErrorT rc;

	memset(inst_id, 0 , sizeof(inst_id));
	strncpy(inst_id, id ,sizeof(inst_id)-1);

	unsigned int max_alarms=500;
	SFmAlarmDataT *p = (SFmAlarmDataT*)malloc(max_alarms*sizeof(SFmAlarmDataT));
	if (p==NULL) error("Not enough memory...");
	if ((rc=fm_get_faults(&inst_id,p,&max_alarms))!=FM_ERR_OK) {
		free(p);
		std::string errstr = fm_error_from_int(rc);
		error(errstr.c_str());
	}
	printf("Ok\n");

	size_t ix = 0;
	for ( ; ix < max_alarms; ++ix ) {
		std::string a;
		fm_alarm_to_string(p+ix,a);
		printf("%s\n",a.c_str());
	}
	free(p);
	exit(0);
}

void get_alarms_by_id(const char *id) {
	fm_alarm_id alm_id;
	EFmErrorT rc;

	memset(alm_id, 0 , sizeof(alm_id));
	strncpy(alm_id, id ,sizeof(alm_id)-1);

	unsigned int max_alarms=500;
	SFmAlarmDataT *p = (SFmAlarmDataT*)malloc(max_alarms*sizeof(SFmAlarmDataT));
	if (p==NULL) error("Not enough memory...");
	if ((rc=fm_get_faults_by_id(&alm_id,p,&max_alarms))!=FM_ERR_OK) {
		free(p);
		std::string errstr = fm_error_from_int(rc);
		error(errstr.c_str());
	}
	printf("Ok\n");

	size_t ix = 0;
	for ( ; ix < max_alarms; ++ix ) {
		std::string a;
		fm_alarm_to_string(p+ix,a);
		printf("%s\n",a.c_str());
	}
	free(p);
	exit(0);
}

int main(int argc, char**argv) {
	int c;

	if (argc < 3) {
		error("Wrong arguments");
	}
	while ( (c=getopt(argc,argv,"c:d:D:g:G:A:"))) {
		switch(c) {
		case 'c':
			create_alarm(optarg);
			break;
		case 'd':
			delete_alarm(optarg);
			break;
		case 'D':
			delete_alarms(optarg);
			break;
		case 'g':
			get_alarm(optarg);
			break;
		case 'G':
			get_alarms(optarg);
			break;
		case 'A':
			get_alarms_by_id(optarg);
			break;
		default:
			error("Invalid option...");
			break;
		}
	}

	return 0;
}