Add makefile and resolve PR comments

src/sonic-eventd/Makefile

@@ -0,0 +1,83 @@
+RM := rm -rf
+EVENTD_TARGET := eventd
+EVENTD_TEST := tests/tests
+EVENTD_TOOL := tools/events_tool
+RSYSLOG-PLUGIN_TARGET := rsyslog_plugin
+RSYSLOG-PLUGIN_TEST: rsyslog_plugin_tests/tests
+CP := cp
+MKDIR := mkdir
+CC := g++
+MV := mv
+LIBS := -levent -lhiredis -lswsscommon -lpthread -lboost_thread -lboost_system -lzmq -lboost_serialization -luuid
+TEST_LIBS := -L/usr/src/gtest -lgtest -lgtest_main -lgmock -lgmock_main
+
+CFLAGS += -Wall -std=c++17 -fPIE -I$(PWD)/../sonic-swss-common/common
+PWD := $(shell pwd)
+
+ifneq ($(MAKECMDGOALS),clean)
+ifneq ($(strip $(C_DEPS)),)
+-include $(C_DEPS) $(OBJS)
+endif
+endif
+
+-include src/subdir.mk
+-include tests/subdir.mk
+-include tools/subdir.mk
+-include rsyslog_plugin/subdir.mk
+
+all: sonic-eventd eventd-tests eventd-tool rsyslog-plugin rsyslog-plugin-tests
+
+sonic-eventd: $(OBJS)
+	@echo 'Building target: $@'
+	@echo 'Invoking: G++ Linker'
+	$(CC) $(LDFLAGS) -o $(EVENTD_TARGET) $(OBJS) $(LIBS)
+	@echo 'Finished building target: $@'
+	@echo ' '
+
+eventd-tool: $(TOOL_OBJS)
+	@echo 'Building target: $@'
+	@echo 'Invoking: G++ Linker'
+	$(CC) $(LDFLAGS) -o $(EVENTD_TOOL) $(TOOL_OBJS) $(LIBS)
+	@echo 'Finished building target: $@'
+	@echo ' '
+
+rsyslog-plugin: $(RSYSLOG-PLUGIN_OBJS)
+	@echo 'Buidling Target: $@'
+	@echo 'Invoking: G++ Linker'
+	$(CC) $(LDFLAGS) -o $(RSYSLOG-PLUGIN_TARGET) $(RSYSLOG-PLUGIN_OBJS) $(LIBS)
+	@echo 'Finished building target: $@'
+	@echo ' '
+
+eventd-tests: $(TEST_OBJS)
+	@echo 'Building target: $@'
+	@echo 'Invoking: G++ Linker'
+	$(CC) $(LDFLAGS) -o $(EVENTD_TEST) $(TEST_OBJS) $(LIBS) $(TEST_LIBS)
+	@echo 'Finished building target: $@'
+	$(EVENTD_TEST)
+	@echo 'Finished running tests'
+	@echo ' '
+
+rsyslog-plugin-tests: $(RSYSLOG-PLUGIN-TEST_OBJS)
+	@echo 'BUILDING target: $@'
+	@echo 'Invoking G++ Linker'
+	$(CC) $(LDFLAGS) -o $(RSYSLOG-PLUGIN_TEST) $(RSYSLOG-PLUGIN-TEST_OBJS) $(LIBS) $(TEST_LIBS)
+	@echo 'Finished building target: $@'
+	$(RSYSLOG-PLUGIN_TEST)
+	@echo 'Finished running tests'
+	@echo ' '
+
+install:
+	$(MKDIR) -p $(DESTDIR)/usr/sbin
+	$(MV) $(EVENTD_TARGET) $(DESTDIR)/usr/sbin
+	$(MV) $(EVENTD_TOOL) $(DESTDIR)/usr/sbin
+	$(MV) $(RSYSLOG-PLUGIN_TARGET) $(DESTDIR)/usr/sbin
+
+deinstall:
+	$(RM) $(DESTDIR)/usr/sbin/$(EVENTD_TARGET)
+	$(RM) $(DESTDIR)/usr/sbin/$(RSYSLOG-PLUGIN_TARGET)
+	$(RM) -rf $(DESTDIR)/usr/sbin
+
+clean:
+	-@echo ' '
+
+.PHONY: all clean dependents

src/sonic-eventd/rsyslog_plugin/main.cpp

@@ -6,10 +6,10 @@
 using namespace std;
 
 void showUsage() {
-    cerr << "Usage for rsyslog_plugin: " << " <option(s)> SOURCES\n"
-        << "Options:\n"
-        << "\t-r,required,type=string\t\tPath to regex file"
-        << "\t-m,required,type=string\t\tYANG module name of source generating syslog message"
+    cout << "Usage for rsyslog_plugin: \n" << "options\n"
+        << "\t-r,required,type=string\t\tPath to regex file\n"
+        << "\t-m,required,type=string\t\tYANG module name of source generating syslog message\n"
+        << "\t-h                     \t\tHelp"
         << endl;
 }
 
@@ -18,31 +18,32 @@ int main(int argc, char** argv) {
     string module_name;
     int option_val;
 
-    while((option_val = getopt(argc, argv, "r:m:")) != -1) {
+    while((option_val = getopt(argc, argv, "r:m:h")) != -1) {
         switch(option_val) {
             case 'r':
-                if(optarg != NULL) {
-                    regex_path = optarg;
-                }
+                regex_path = optarg;
                 break;
             case 'm':
-                if(optarg != NULL) {
-                    module_name = optarg;
-                }
+                module_name = optarg;
                 break;
+            case 'h':
+            case '?':
             default:
                 showUsage();
                 return 1;
         }
     }
 
     if(regex_path.empty() || module_name.empty()) { // Missing required rc path
-        showUsage();
+        cerr << "Error: Missing regex_path and module_name." << endl;
         return 1;
     }
 
-    SyslogParser* parser = new SyslogParser({}, json::array());
-    RsyslogPlugin* plugin = new RsyslogPlugin(parser, module_name, regex_path);
+    RsyslogPlugin* plugin = new RsyslogPlugin(module_name, regex_path);
+    if(!plugin->onInit()) {
+        SWSS_LOG_ERROR("Rsyslog plugin was not able to be initialized.\n");
+	return 1;
+    }
 
     plugin->run();
     return 0;

src/sonic-eventd/rsyslog_plugin/rsyslog_plugin.cpp

@@ -6,74 +6,82 @@
 #include "rsyslog_plugin.h"
 #include "common/logger.h"
 #include "common/json.hpp"
-#include "common/events.h"
 
 using namespace std;
 using namespace swss;
 using json = nlohmann::json;
 
-void RsyslogPlugin::onMessage(string msg) {
-    string tag = "";
+bool RsyslogPlugin::onMessage(string msg) {
+    string tag;
     event_params_t param_dict;
-    if(!parser->parseMessage(msg, tag, param_dict)) {
-        SWSS_LOG_INFO("%s was not able to be parsed into a structured event\n", msg.c_str());
+    if(!m_parser->parseMessage(msg, tag, param_dict)) {
+        SWSS_LOG_DEBUG("%s was not able to be parsed into a structured event\n", msg.c_str());
+	return false;
     } else {
-	int return_code = event_publish(fetchHandle(), tag, &param_dict);
-	if (return_code != 0) {
-            SWSS_LOG_INFO("rsyslog_plugin was not able to publish event for %s\n", tag.c_str());
-	}
-    }
-}
-
-[[noreturn]] void RsyslogPlugin::run() {
-    while(true) {
-        string line;
-        getline(cin, line);
-        if(line.empty()) {
-            continue;
+        int return_code = event_publish(m_event_handle, tag, &param_dict);
+        if (return_code != 0) {
+            SWSS_LOG_ERROR("rsyslog_plugin was not able to publish event for %s. last thrown event error: %d\n", tag.c_str(), event_last_error());
+	    return false;
         }
-        onMessage(line);
+	return true;
     }
 }
 
 bool RsyslogPlugin::createRegexList() {
     fstream regex_file;
-    regex_file.open(regex_path, ios::in);
+    regex_file.open(m_regex_path, ios::in);
     if (!regex_file) {
-        SWSS_LOG_ERROR("No such path exists: %s for source %s\n", regex_path.c_str(), module_name.c_str());
+        SWSS_LOG_ERROR("No such path exists: %s for source %s\n", m_regex_path.c_str(), m_module_name.c_str());
         return false;
     }
     try {
-        regex_file >> parser->regex_list;
+        regex_file >> m_parser->m_regex_list;
     } catch (exception& exception) {
-        SWSS_LOG_ERROR("Invalid JSON file: %s, throws exception: %s\n", regex_path.c_str(), exception.what());
+        SWSS_LOG_ERROR("Invalid JSON file: %s, throws exception: %s\n", m_regex_path.c_str(), exception.what());
         return false;
     }
 
-    string regex_string = "";
+    string regex_string;
     regex expression;
 
-    for(long unsigned int i = 0; i < parser->regex_list.size(); i++) {
+    for(long unsigned int i = 0; i < m_parser->m_regex_list.size(); i++) {
         try {
-            regex_string = parser->regex_list[i]["regex"];
+            regex_string = m_parser->m_regex_list[i]["regex"];
+	    string tag = m_parser->m_regex_list[i]["tag"];
+	    vector<string> params = m_parser->m_regex_list[i]["params"];
             regex expr(regex_string);
             expression = expr;
         } catch (exception& exception) {
             SWSS_LOG_ERROR("Invalid regex, throws exception: %s\n", exception.what());
             return false;
         }
-        parser->expressions.push_back(expression);
+        m_parser->m_expressions.push_back(expression);
     }
     regex_file.close();
     return true;
 }
 
-
-RsyslogPlugin::RsyslogPlugin(SyslogParser* syslog_parser, string mod_name, string path) {
-    parser = syslog_parser;
-    module_name = mod_name;
-    regex_path = path;
-    if(!onInit()) {
-        SWSS_LOG_ERROR("Initializing rsyslog plugin failed.\n");
+[[noreturn]] void RsyslogPlugin::run() {
+    while(true) {
+        string line;
+        getline(cin, line);
+        if(line.empty()) {
+            continue;
+        }
+        if(!onMessage(line)) {
+            SWSS_LOG_DEBUG("RsyslogPlugin was not able to parse or publish the log message: %s\n", line.c_str());
+	}
     }
 }
+
+bool RsyslogPlugin::onInit() {
+    m_event_handle = events_init_publisher(m_module_name);
+    bool return_code = createRegexList();
+    return (m_event_handle != NULL && return_code);
+}
+
+RsyslogPlugin::RsyslogPlugin(string module_name, string regex_path) {
+    m_parser = new SyslogParser({}, json::array());
+    m_module_name = module_name;
+    m_regex_path = regex_path;
+}

src/sonic-eventd/rsyslog_plugin/rsyslog_plugin.h

@@ -18,25 +18,17 @@ using json = nlohmann::json;
 
 class RsyslogPlugin {
 public:
-    RsyslogPlugin(SyslogParser* syslog_parser, string mod_name, string path);
-    void onMessage(string msg);
+    bool onInit();
+    bool onMessage(string msg);
     void run();
-    bool createRegexList();
-    event_handle_t fetchHandle() {
-        return event_handle;
-    }
-    SyslogParser* parser;
+    RsyslogPlugin(string module_name, string regex_path);
 private:
-    string regex_path;
-    string module_name;
-    event_handle_t event_handle;
-
-    bool onInit() {
-        event_handle = events_init_publisher(module_name);
-        int return_code = createRegexList();
-	return (event_handle != NULL && return_code == 0); 
-    }
+    SyslogParser* m_parser;
+    event_handle_t m_event_handle;
+    string m_regex_path;
+    string m_module_name;
 
+    bool createRegexList();
 };
 
 #endif

src/sonic-eventd/rsyslog_plugin/subdir.mk

@@ -0,0 +1,13 @@
+CC := g++
+
+RSYSLOG-PLUGIN_TEST_OBJS += ./rsyslog_plugin/rsyslog_plugin.o ./rsyslog_plugin/syslog_parser.o
+RSYSLOG-PLUGIN_OBJS += ./rsyslog_plugin/rsyslog_plugin.o ./rsyslog_plugin/syslog_parser.o ./rsyslog_plugin/main.o
+
+C_DEPS += ./rsyslog_plugin/rsyslog_plugin.d ./rsyslog_plugin/syslog_parser.d ./rsyslog_plugin/main.d
+
+rsyslog_plugin/%.o: rsyslog_plugin/%.cpp
+	@echo 'Building file: $<'
+	@echo 'Invoking: GCC C++ Compiler'
+	$(CC) -D__FILENAME__="$(subst rsyslog_plugin/,,$<)" $(CFLAGS) -c -fmessage-length=0 -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@)" -o "$(@)" "$<"
+	@echo 'Finished building: $<
+	'@echo ' '

src/sonic-eventd/rsyslog_plugin/syslog_parser.cpp

@@ -16,34 +16,23 @@ using namespace std;
 */
 
 bool SyslogParser::parseMessage(string message, string& event_tag, event_params_t& param_map) {
-    for(long unsigned int i = 0; i < regex_list.size(); i++) {
+    for(long unsigned int i = 0; i < m_regex_list.size(); i++) {
         smatch match_results;
-	regex_search(message, match_results, expressions[i]);
-	vector<string> groups;
-	vector<string> params;
-	try {
-	    event_tag = regex_list[i]["tag"];
-	    vector<string> p = regex_list[i]["params"];
-	    params = p;
-	} catch (exception& exception) {
-	    SWSS_LOG_ERROR("Invalid regex list, throws exception: %s\n", exception.what());
-	    return false;
-	}
-	// first match in groups is entire message
-	for(long unsigned int j = 1; j < match_results.size(); j++) {
-	    groups.push_back(match_results.str(j));
-	}
-	if (groups.size() == params.size()) { // found matching regex
-            transform(params.begin(), params.end(), groups.begin(), inserter(param_map, param_map.end()), [](string a, string b) {
-	        return make_pair(a,b);
-	    });
-	    return true;
+	vector<string> params = m_regex_list[i]["params"];
+	if(!regex_search(message, match_results, m_expressions[i]) || params.size() != match_results.size() - 1) {
+            continue;
 	}
+	// found matching regex
+	event_tag = m_regex_list[i]["tag"];
+        transform(params.begin(), params.end(), match_results.begin() + 1, inserter(param_map, param_map.end()), [](string a, string b) {
+	    return make_pair(a,b);
+	});
+	return true;
     }
     return false;
 }
 
-SyslogParser::SyslogParser(vector<regex> regex_expressions, json list) {
-    expressions = regex_expressions;
-    regex_list = list;
+SyslogParser::SyslogParser(vector<regex> expressions, json regex_list) {
+    m_expressions = expressions;
+    m_regex_list = regex_list;
 }

src/sonic-eventd/rsyslog_plugin/syslog_parser.h

@@ -18,11 +18,11 @@ using json = nlohmann::json;
 
 class SyslogParser {
 public:
-    SyslogParser(vector<regex> regex_expressions, json list);
-    bool parseMessage(string message, string& tag, event_params_t& param_dict);
+    vector<regex> m_expressions;
+    json m_regex_list = json::array();
 
-    vector<regex> expressions;
-    json regex_list = json::array();
+    SyslogParser(vector<regex> expressions, json regex_list);
+    bool parseMessage(string message, string& tag, event_params_t& param_dict);
 };
 
 #endif