From a4ca11512df953d2aa1e9614aef4df6cc531bb3c Mon Sep 17 00:00:00 2001 From: 6638678 <6638678@1ed66053-1c2d-0410-8867-f7571e6e31d3> Date: Tue, 28 Sep 2010 01:38:20 +0000 Subject: [PATCH] Add SNMP code git-svn-id: http://10.144.169.20/repos/um/branches/l7vsd-3.x-ramiel-epoll-cond@10311 1ed66053-1c2d-0410-8867-f7571e6e31d3 --- l7vsd/include/mibdata.h | 136 ++++ l7vsd/include/snmp_info.h | 176 +++++ l7vsd/include/snmpagent.h | 156 ++++ l7vsd/include/snmpagent_impl.h | 261 +++++++ l7vsd/include/snmpfunc.h | 299 +++++++ l7vsd/src/mibdata.cpp | 499 ++++++++++++ l7vsd/src/snmpagent.cpp | 244 ++++++ l7vsd/src/snmpagent_impl.cpp | 990 +++++++++++++++++++++++ l7vsd/src/snmpfunc.cpp | 1687 ++++++++++++++++++++++++++++++++++++++++ 9 files changed, 4448 insertions(+) create mode 100644 l7vsd/include/mibdata.h create mode 100644 l7vsd/include/snmp_info.h create mode 100644 l7vsd/include/snmpagent.h create mode 100644 l7vsd/include/snmpagent_impl.h create mode 100644 l7vsd/include/snmpfunc.h create mode 100644 l7vsd/src/mibdata.cpp create mode 100644 l7vsd/src/snmpagent.cpp create mode 100644 l7vsd/src/snmpagent_impl.cpp create mode 100644 l7vsd/src/snmpfunc.cpp diff --git a/l7vsd/include/mibdata.h b/l7vsd/include/mibdata.h new file mode 100644 index 00000000..3d56c6be --- /dev/null +++ b/l7vsd/include/mibdata.h @@ -0,0 +1,136 @@ +/*! + * @file mibdata.h + * @brief mibdata module. + * + * L7VSD: Linux Virtual Server for Layer7 Load Balancing + * Copyright (C) 2010 NTT COMWARE Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + **********************************************************************/ +#ifndef __MIBDATA_H__ +#define __MIBDATA_H__ + +#include "error_code.h" +#include "l7vsd.h" +#include "snmp_info.h" +#include +#include +#include +#include + +#define L7VS_IPADDR_LEN (128) + +namespace l7vs +{ + +//! @class mibdata +//! @brief this class is mib data cache class. + class mibdata : private boost::noncopyable + { + protected: + netsnmp_table_data_set* vs_table; + netsnmp_table_data_set* rs_table; + int vs_table_size; + int rs_table_size; + int replication_state; + + mibdata() {}; + ~mibdata() {}; + mibdata(const mibdata &); + mibdata& operator=(const mibdata &); + + /*! + * update virtual service table infomation. + * + * @param l7vsd * l7vsd pointer + * @param error_code & error code + * @retrun void + */ + void update_vs_table(l7vsd *, error_code &); + + /*! + * update real server table infomation. + * + * @param const std::vector & temporary real server list + * @param error_code & error code + * @retrun void + */ + void update_rs_table(const std::vector &, error_code &); + + /*! + * update replication state. + * + * @param l7vsd * l7vsd pointer + * @param error_code & error code + * @retrun void + */ + void update_replication_state(l7vsd *, error_code &); + + public: + /*! + * get mibdata instance. + * + * @retrun mibdata instance + */ + static mibdata& get_instance(); + + /*! + * collect mibdata in l7vsd. + * + * @param l7vsd * l7vsd pointer + * @param error_code & error code + * @retrun void + */ + void collect_mibdata(l7vsd *, error_code &); + + /*! + * set virtual service data set. + * + * @param netsnmp_table_data_set * virtual service data set + * @retrun void + */ + void set_vs_table(netsnmp_table_data_set *); + + /*! + * set real server data set. + * + * @param netsnmp_table_data_set * real server data set + * @retrun void + */ + void set_rs_table(netsnmp_table_data_set *); + + /*! + * get virtual service table size + * + * @retrun int virtual service table size + */ + inline int get_vs_table_size() { + return vs_table_size; + } + + /*! + * get replication state. + * + * @retrun int replication state + */ + inline int get_replication_state() { + return replication_state; + } + }; +} + +#endif //__MIBDATA_H__ diff --git a/l7vsd/include/snmp_info.h b/l7vsd/include/snmp_info.h new file mode 100644 index 00000000..443bdc22 --- /dev/null +++ b/l7vsd/include/snmp_info.h @@ -0,0 +1,176 @@ +/*! + * @file snmp_info.h + * @brief snmp function common header. + * + * L7VSD: Linux Virtual Server for Layer7 Load Balancing + * Copyright (C) 2010 NTT COMWARE Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + */ +#ifndef __SNMP_INFO_H__ +#define __SNMP_INFO_H__ + + +#include +#include +#include "logger.h" + +namespace l7vs +{ + + struct snmp_info { + enum SNMP_OPTION_FLAG_TAG { + SNMP_ENABLE_OPTION_FLAG = 0x0001, + SNMP_LOGTRAP_OPTION_FLAG = 0x0002, + SNMP_LOGTRAP_LEVEL_OPTION_FLAG = 0x0004, + SNMP_INTERVAL_OPTION_FLAG = 0x0008, + SNMP_REFRESH_OPTION_FLAG = 0x0010, + SNMP_REFRESH_ALL_OPTION_FLAG = 0x0020, + SNMP_TCP_SERVICE_OPTION_FLAG = 0x0040, + SNMP_PROTOCOL_MODULE_OPTION_FLAG = 0x0080 + }; + unsigned int enabled; + unsigned int logtrap_enabled; + LOG_LEVEL_TAG logtrap_level; + unsigned int interval; + time_t start_date; + time_t request_last_date; + time_t trap_last_date; + unsigned long long snmp_get_requests; + unsigned long long snmp_set_requests; + unsigned long long snmp_trap_count; + boost::asio::ip::tcp::endpoint vs_endpoint; + std::string protocol; + int option_set_flag; + + snmp_info() : enabled(0), logtrap_enabled(0), logtrap_level(LOG_LV_NONE), + interval(0), start_date(0), + request_last_date(0), trap_last_date(0), + snmp_get_requests(0ull), snmp_set_requests(0ull), snmp_trap_count(0ull),option_set_flag(0) {} + snmp_info(const snmp_info &in) + : enabled(in.enabled), + logtrap_enabled(in.logtrap_enabled), + logtrap_level(in.logtrap_level), + interval(in.interval), + start_date(in.start_date), + request_last_date(in.request_last_date), + trap_last_date(in.trap_last_date), + snmp_get_requests(in.snmp_get_requests), + snmp_set_requests(in.snmp_set_requests), + snmp_trap_count(in.snmp_trap_count), + vs_endpoint(in.vs_endpoint), + protocol(in.protocol), + option_set_flag(in.option_set_flag) {} + snmp_info &operator=(const snmp_info &in) { + enabled = in.enabled; + logtrap_enabled = in.logtrap_enabled; + logtrap_level = in.logtrap_level; + interval = in.interval; + start_date = in.start_date; + request_last_date = in.request_last_date; + trap_last_date = in.trap_last_date; + snmp_get_requests = in.snmp_get_requests; + snmp_set_requests = in.snmp_set_requests; + snmp_trap_count = in.snmp_trap_count; + vs_endpoint = in.vs_endpoint; + protocol = in.protocol; + option_set_flag = in.option_set_flag; + + return *this; + } + template + friend std::basic_ostream& operator<<( + std::basic_ostream& os, + const snmp_info &info) { + static const int MAX_TIME_LEN = 20; + char start_date[MAX_TIME_LEN] = {0}; + char request_last_date[MAX_TIME_LEN] = {0}; + char trap_last_date[MAX_TIME_LEN] = {0}; + strftime(start_date, sizeof(start_date), + "%Y-%m-%d %H:%M:%S", gmtime(&(info.start_date))); + strftime(request_last_date, sizeof(request_last_date), + "%Y-%m-%d %H:%M:%S", gmtime(&(info.request_last_date))); + strftime(trap_last_date, sizeof(trap_last_date), + "%Y-%m-%d %H:%M:%S", gmtime(&(info.trap_last_date))); + + os << "{"; + os << boost::format("flag=%d; " + "logtrap=%d; " + "logtrap_level=%s; " + "interval=%d; " + "start_date=%s; " + "request_last_date = %s; " + "trap_last_date = %s ;" + "snmp_get_requests = %d ;" + "snmp_set_requests = %d ;" + "snmp_trap_count= %d; " + "vs_endpoint= %s:%d; " + "protocol = %s; " + "option_set_flag = %x }") + % info.enabled + % info.logtrap_enabled + % info.logtrap_level + % info.interval + % (info.start_date == 0 ? "none" : start_date) + % (info.request_last_date == 0 ? "none" : request_last_date) + % (info.trap_last_date == 0 ? "none" : trap_last_date) + % info.snmp_get_requests + % info.snmp_set_requests + % info.snmp_trap_count + % info.vs_endpoint.address().to_string() + % info.vs_endpoint.port() + % info.protocol + % info.option_set_flag; + return os; + + } +private: + friend class boost::serialization::access; + template void serialize(Archive &ar, const unsigned int version) { + ar & enabled; + ar & logtrap_enabled; + ar & logtrap_level; + ar & interval; + ar & start_date; + ar & request_last_date; + ar & trap_last_date; + ar & snmp_get_requests; + ar & snmp_set_requests; + ar & snmp_trap_count; + ar & vs_endpoint; + ar & protocol; + ar & option_set_flag; + + } + + }; + + struct rsdata { + int index; + int vs_index; + int address_type; + char address[128]; + int port; + int forward; + int weigth; + int active_conn; + int inactive_conn; + }; + +} + +#endif //__SNMP_INFO_H__ + diff --git a/l7vsd/include/snmpagent.h b/l7vsd/include/snmpagent.h new file mode 100644 index 00000000..fceb27b1 --- /dev/null +++ b/l7vsd/include/snmpagent.h @@ -0,0 +1,156 @@ +/*! + * @file snmpagent.h + * @brief snmpagent module. + * + * L7VSD: Linux Virtual Server for Layer7 Load Balancing + * Copyright (C) 2010 NTT COMWARE Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + **********************************************************************/ +#ifndef __SNMPAGENT_H__ +#define __SNMPAGENT_H__ + +#include "l7vsd.h" +#include "snmpagent_impl.h" + +namespace l7vs +{ + +//! @class snmpagent +//! @brief this class is snmpagent class. + class snmpagent : private boost::noncopyable + { + public: + /*! + * constructor. + * + * @param[in] l7vsd pointer + */ + snmpagent(l7vsd *); + + /*! + * destructor. + * + */ + ~snmpagent() {}; + + /*! + * push the trap message into trap message queue. + * + * @param[in] in_trapmessage is trap message + * @param[in/out] err is error code + * @retrun void + */ + static void push_trapmessage(trapmessage &in_trapmessage, error_code& err); + + /*! + * set snmp function enable + * + * @retrun void + */ + static void enable(); + + /*! + * set snmp function disable + * + * @retrun void + */ + static void disable(); + + /*! + * set mib cache update interval. + * + * @param[in] in_interval is cache update interval + * @retrun void + */ + static void set_interval(const unsigned int in_interval); + + /*! + * set log trap enable + * @retrun void + */ + static void logtrap_enable(); + + /*! + * set log trap disable + * @retrun void + */ + static void logtrap_disable(); + + /*! + * set log trap level. + * + * @param[in] in_level is log trap level + * @retrun void + */ + static void set_logtrap_level(const LOG_LEVEL_TAG in_level); + + /*! + * get snmp infomation. + * + * @return snmp infomation + */ + static snmp_info get_snmp_info(); + + /*! + * start snmp function. + * + * @param[in/out] error_code is error code + * @return void + */ + static void start(error_code&); + + /*! + * stop snmp function. + * + * @return void + */ + static void stop(); + + /*! + * refresh all the statistics. + * + * @return void + */ + static void refresh_all_statistics(); + + /*! + * refresh a special virtual service's statistics. + * + * @param[in] vs_endpoint is virtual service's endpoint + * @param[in] protocol is virtual service's protocol + * @return void + */ + static void refresh_statistics(const boost::asio::ip::tcp::endpoint &vs_endpoint, + const std::string &protocol); + /*! + * finalize. + * + * @return void + */ + void finalize(); + protected: + /*! + * constructor. + * + */ + snmpagent(){}; + + }; +} + +#endif //__SUBAGENT_H__ diff --git a/l7vsd/include/snmpagent_impl.h b/l7vsd/include/snmpagent_impl.h new file mode 100644 index 00000000..6e475acf --- /dev/null +++ b/l7vsd/include/snmpagent_impl.h @@ -0,0 +1,261 @@ +/*! + * @file snmpagent_impl.h + * @brief snmpagent implement module. + * + * L7VSD: Linux Virtual Server for Layer7 Load Balancing + * Copyright (C) 2010 NTT COMWARE Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + **********************************************************************/ +#ifndef __SNMPAGENT_IMPL_H__ +#define __SNMPAGENT_IMPL_H__ + +#include "l7vsd.h" +#include "snmp_info.h" +#include +#include +#include +#include +#include +#include +#include "error_code.h" +#include "boost/date_time/posix_time/posix_time.hpp" + +namespace l7vs +{ + +//! @class snmpagent_impl +//! @brief this class is snmpagent implement class. + class snmpagent_impl : private boost::noncopyable + { + + public: + + //! trap function type + typedef int trapfunc(const std::string&); + + //!trap function map type + typedef std::map trapfunc_type; + + //!string log level map type + typedef std::map string_loglevel_map_type; + protected: + bool initialized; + bool start_flag; + l7vsd *vsd; + trapfunc_type trapfunc_map; + atomic trap_polling_interval; + atomic trap_queue_max_size; + atomic enabled; + unsigned int logtrap_enabled; + LOG_LEVEL_TAG logtrap_level; + atomic interval; + atomic start_date; + atomic request_last_date; + atomic trap_last_date; + atomic snmp_get_requests; + atomic snmp_set_requests; + atomic snmp_trap_count; + std::deque trap_msg_queue; + boost::condition trap_msg_queue_condition; + boost::mutex trap_msg_queue_condition_mutex; + string_loglevel_map_type string_loglevel_map; + boost::posix_time::ptime mib_collect_last_time; + boost::thread trap_thread; + boost::thread process_mib_thread; + + snmpagent_impl() {}; + ~snmpagent_impl() {}; + snmpagent_impl(const snmpagent_impl&); + snmpagent_impl& operator=(const snmpagent_impl &); + + /*! + * process mib get item thread function. + * + * @retrun void + */ + void process_mib_run(); + + /*! + * process trap thread function. + * + * @retrun void + */ + void trap_run(); + + /*! + * check mib data timeout. + * + * @retrun void + */ + bool check_timeout(); + + /*! + * load configure file setting. + * + * @retrun void + */ + void load_config(); + + public: + + /*! + * create and return a snmpagent_impl instance. + * + * @retrun snmpagent_impl & snmpagent_impl' instance + */ + static snmpagent_impl &get_instance(); + + /*! + * snmpagent_impl class initialize. + * + * @param error_code & error code + * @retrun void + */ + void init(error_code &); + + /*! + * push the trap message into trap message queue. + * + * @param[in] in_trapmessage is trap message + * @param[in/out] err is error code + * @retrun void + */ + void push_trapmessage(trapmessage &in_trapmessage, error_code& err); + + /*! + * snmpagent function start. + * + * @param[in/out] error_code is error code + * @retrun void + */ + void start(error_code&); + + /*! + * snmpagent function stop. + * + * @retrun void + */ + void stop(); + + /*! + * set snmp function enable + * + * @retrun void + */ + void enable(); + + /*! + * set snmp function disable + * + * @retrun void + */ + void disable(); + + /*! + * set log trap enable + * @retrun void + */ + void logtrap_enable(); + + /*! + * set log trap disable + * @retrun void + */ + void logtrap_disable(); + + /*! + * set log trap level. + * + * @param[in] in_level is log trap level + * @retrun void + */ + void set_logtrap_level(const LOG_LEVEL_TAG in_level); + + /*! + * set mib cache update interval. + * + * @param[in] in_interval is cache update interval + * @retrun void + */ + void set_interval(const unsigned int in_interval); + + /*! + * refresh all the statistics. + * + * @return void + */ + void refresh_all_statistics(); + + /*! + * refresh a special virtual service's statistics. + * + * @param[in] vs_endpoint is virtual service's endpoint + * @param[in] protocol is virtual service's protocol + * @return void + */ + void refresh_statistics(const boost::asio::ip::tcp::endpoint &vs_endpoint, const std::string &protocol); + + /*! + * set vsd infomation. + * + * @param[in] vsd is vsd pointer. + * @retrun void + */ + void set_vsd_info(l7vsd *vsd); + + /*! + * get snmp infomation. + * + * @retrun snmp_info is snmp infomation. + */ + snmp_info get_snmp_info(); + + /*! + * collect mib data. + * + * @param[in] error_code is err code. + * @retrun void + */ + void collect_mibdata(error_code &); + + /*! + * finalize. + * + * @retrun void + */ + void finalize(); + + /*! + * increment get request count. + * + * @retrun void + */ + void increment_getrequest_count(); + + /*! + * increment set request count. + * + * @retrun void + */ + void increment_setrequest_count(); + }; + +} + +#endif //__SNMPAGENT_IMPL_H__ + diff --git a/l7vsd/include/snmpfunc.h b/l7vsd/include/snmpfunc.h new file mode 100644 index 00000000..c350d7d2 --- /dev/null +++ b/l7vsd/include/snmpfunc.h @@ -0,0 +1,299 @@ +/*! + * @file snmpfunc.h + * @brief snmp function module. + * + * L7VSD: Linux Virtual Server for Layer7 Load Balancing + * Copyright (C) 2010 NTT COMWARE Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + */ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.create-dataset.conf 17337 2009-01-01 14:28:29Z magfr $ + * : mib2c.scalar.conf 17337 2009-01-01 14:28:29Z magfr $ + * : mib2c.notify.conf 17455 2009-04-05 09:53:29Z magfr $ + */ +#ifndef __SNMPFUNC_H__ +#define __SNMPFUNC_H__ + +#include +#include +#include +#include +#include + +using namespace l7vs; + +/* + * function declarations + */ + +/*! + * handle for virtual service count. + * + */ +int handle_get_vstable_count(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests); + +/*! + * handle for replication state. + * + */ +int handle_get_rep_state(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests); + +/*! + * handle for virtual service table. + * + */ +int handle_get_vstable(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests); + +/*! + * handle for real server table. + * + */ +int handle_get_rstable(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests); + +/*! + * initialize snmp scaler and table data set handles. + * + * @param[in] error_code& is trap error code + * @retrun void + */ +void init_snmp_handles(error_code& err); + +/*! + * initialize virtual service table data set. + * + * @param[in] error_code& is trap error code + * @retrun void + */ +void initialize_virtual_service_table(error_code& err); + +/*! + * initialize real server table data set. + * + * @param[in] error_code& is trap error code + * @retrun void + */ +void initialize_real_server_table(error_code& err); + +/*! + * send service start trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_service_start(const std::string&); + +/*! + * send service stop trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_service_stop(const std::string&); + +/*! + * send virtual service add trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_vs_add(const std::string&); + +/*! + * send virtual service change trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_vs_change(const std::string&); + +/*! + * send virtual service remove trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_vs_remove(const std::string&); + +/*! + * send real server add trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_rs_add(const std::string&); + +/*! + * send real server change trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_rs_change(const std::string&); + +/*! + * send real server remove trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_rs_remove(const std::string&); + +/*! + * send upstream QoS alert on trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_up_qos_alert_on(const std::string&); + +/*! + * send upstream QoS alert off trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_up_qos_alert_off(const std::string&); + +/*! + * send downstream QoS alert on trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_down_qos_alert_on(const std::string&); + +/*! + * send downstream QoS alert off trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_down_qos_alert_off(const std::string&); + +/*! + * send session pool alert on trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_sessionpool_alert_on(const std::string&); + +/*! + * send session pool alert off trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_sessionpool_alert_off(const std::string&); + +/*! + * send fatal log trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_fatal(const std::string&); + +/*! + * send error log trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_error(const std::string&); + +/*! + * send warn log trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_warn(const std::string&); + +/*! + * send info log trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_info(const std::string&); + +/*! + * send debug log trap. + * + * @param[in] const std::string& is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int trap_debug(const std::string&); + +/* + * column number definitions for table l7vsVsTable + */ +#define COLUMN_L7VSVSINDEX (1) +#define COLUMN_L7VSVSPROTOCOL (2) +#define COLUMN_L7VSVSADDRTYPE (3) +#define COLUMN_L7VSVSADDR (4) +#define COLUMN_L7VSVSPORT (5) +#define COLUMN_L7VSVSPROTOCOLMODULENAME (6) +#define COLUMN_L7VSVSPROTOCOLMODULEOPTIONS (7) +#define COLUMN_L7VSVSSCHEDULEMODULENAME (8) +#define COLUMN_L7VSVSSCHEDULEMODULEOPTIONS (9) +#define COLUMN_L7VSVSSORRYADDRTYPE (10) +#define COLUMN_L7VSVSSORRYADDR (11) +#define COLUMN_L7VSVSSORRYPORT (12) +#define COLUMN_L7VSVSSORRYCONNLIMIT (13) +#define COLUMN_L7VSVSSORRYFORCEENABLED (14) +#define COLUMN_L7VSVSTHROUGHPUTUP (15) +#define COLUMN_L7VSVSTHROUGHPUTDOWN (16) +#define COLUMN_L7VSVSTHROUGHPUTUPQOS (17) +#define COLUMN_L7VSVSTHROUGHPUTDOWNQOS (18) +#define COLUMN_L7VSVSSSLFLAG (19) +#define COLUMN_L7VSVSSESSIONPOOLCOUNT (20) +#define COLUMN_L7VSVSSESSIONACTIVECOUNT (21) +#define COLUMN_L7VSVSSESSIONWAITCOUNT (22) +#define COLUMN_L7VSVSHTTPTOTALCOUNT (23) +#define COLUMN_L7VSVSHTTPGETCOUNT (24) +#define COLUMN_L7VSVSHTTPPOSTCOUNT (25) +#define COLUMN_L7VSVSRSNUMBER (26) + +/* + * column number definitions for table l7vsRsTable + */ +#define COLUMN_L7VSRSINDEX (1) +#define COLUMN_L7VSRSVSINDEX (2) +#define COLUMN_L7VSRSADDRTYPE (3) +#define COLUMN_L7VSRSADDR (4) +#define COLUMN_L7VSRSPORT (5) +#define COLUMN_L7VSRSFORWARD (6) +#define COLUMN_L7VSRSWEIGHT (7) +#define COLUMN_L7VSRSACTIVECONN (8) +#define COLUMN_L7VSRSINACTIVECONN (9) + +#endif //__SNMPFUNC_H__ diff --git a/l7vsd/src/mibdata.cpp b/l7vsd/src/mibdata.cpp new file mode 100644 index 00000000..9a599757 --- /dev/null +++ b/l7vsd/src/mibdata.cpp @@ -0,0 +1,499 @@ +/*! + * @file mibdata.cpp + * @brief mibdata module. + * + * L7VSD: Linux Virtual Server for Layer7 Load Balancing + * Copyright (C) 2010 NTT COMWARE Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + **********************************************************************/ +#include "mibdata.h" +#include "snmpfunc.h" + + +namespace l7vs +{ + /*! + * update virtual service table infomation. + * + * @param l7vsd * l7vsd pointer + * @param error_code & error code + * @retrun void + */ + void mibdata::update_vs_table(l7vsd *in_vsd, error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 63, "mibdata::update_vs_table", __FILE__, __LINE__); + + if (in_vsd == NULL) { + std::string msg("in_vsd pointer is NULL."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 11, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + if (vs_table == NULL) { + std::string msg("vs_table pointer is NULL."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 12, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "mibdata::update_vs_table arguments:"; + debugstr << boost::format("in_vsd=%p") % in_vsd; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 64, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + oid index[1] = {0}; + netsnmp_table_row *row = NULL; + int vs_index = 0; + std::vector rs_vector; + + int protocol = 0; + char vs_ipaddress[L7VS_IPADDR_LEN] = {0}; + char sorry_ipaddress[L7VS_IPADDR_LEN] = {0}; + int vs_ipaddress_type = 1; + int sorry_ipaddress_type = 1; + int vs_port = 0; + int sorry_port = 0; + + struct counter64 sorry_maxconnection = { + 0 + }; + struct counter64 throughput_upstream = { + 0 + }; + struct counter64 throughput_downstream = { + 0 + }; + struct counter64 qos_upstream = { + 0 + }; + struct counter64 qos_downstream = { + 0 + }; + struct counter64 http_requests = { + 0 + }; + struct counter64 http_get_requests = { + 0 + }; + struct counter64 http_post_requests = { + 0 + }; + + int pool_session_count = 0; + int active_session_count = 0; + int waiting_session_count = 0; + + //get virtualservice list mutex + boost::mutex &virtualservice_list_mutex = in_vsd->get_virtualservice_list_mutex(); + { + boost::mutex::scoped_lock lock(virtualservice_list_mutex); + + l7vsd::vslist_type &virtualservice_list = in_vsd->get_virtualservice_list(); + + //delete the surplus data from vs table + if (virtualservice_list.size() < static_cast(vs_table_size)) { + for (size_t i = vs_table_size; i > virtualservice_list.size(); i--) { + index[0] = i; + row = netsnmp_table_data_get_from_oid(vs_table->table, index, 1); + if (row == NULL) continue; + netsnmp_table_dataset_remove_and_delete_row(vs_table, row); + } + } + + //set virtual service table size + vs_table_size = virtualservice_list.size(); + + //update virtual service table + for (l7vsd::vslist_type::iterator it = virtualservice_list.begin(); + it != virtualservice_list.end(); it++) { + index[0] = vs_index; + + //get row pointer + row = netsnmp_table_data_get_from_oid(vs_table->table, index, 1); + if (row == NULL) { + row = netsnmp_create_table_data_row(); + if (row == NULL) { + std::string msg("create virtualservice table row failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 13, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } else { + + netsnmp_table_row_add_index(row, ASN_INTEGER, (void*)index, sizeof(int)); + netsnmp_table_dataset_add_row(vs_table, row); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "function : mibdata::update_vs_table : vs_table add row."; + boost::format("vs_index=%d") % vs_index; + + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 65, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + } + } + + virtualservice_element &srv = (*it)->get_element(); + + //get virtual service IP address infomation + if (srv.udpmode) { + protocol = IPPROTO_UDP; + if (srv.udp_recv_endpoint.address().is_v4()) { + strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN); + } else { + strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN); + vs_ipaddress_type = 2; + } + vs_port = srv.udp_recv_endpoint.port(); + } else { + protocol = IPPROTO_TCP; + if (srv.tcp_accept_endpoint.address().is_v4()) { + strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN); + } else { + strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN); + vs_ipaddress_type = 2; + } + vs_port = srv.tcp_accept_endpoint.port(); + } + + //get sorry server IP address infomation + if (srv.sorry_endpoint.address().is_v4()) { + strncpy(sorry_ipaddress, srv.sorry_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN); + } else { + strncpy(sorry_ipaddress, srv.sorry_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN); + sorry_ipaddress_type = 2; + } + sorry_port = srv.sorry_endpoint.port(); + + //get protocol mudule option string + std::stringstream protocol_module_arg; + BOOST_FOREACH(std::string str, srv.protocol_args) { + protocol_module_arg << str << " "; + } + + //set schedule module option string + std::string schedule_module_arg(" "); + + //set ssl flag + int ssl_flag = srv.ssl_file_name == "" ? 0 : 1; + + //set realserver size + int rs_size = srv.realserver_vector.size(); + + //get http statstics + protocol_module_base *protocol_module_ptr = (*it)->get_protocol_module(); + stats_base& base_stats = protocol_module_ptr->get_stats(); + if ( base_stats.get_mode() == stats_base::MODE_HTTP ) { + http_stats &httpstats = static_cast(base_stats); + http_requests.low = httpstats.http_requests.get(); + http_get_requests.low = httpstats.http_get_requests.get(); + http_post_requests.low = httpstats.http_post_requests.get(); + } + + //set sorry max connection + sorry_maxconnection.low = srv.sorry_maxconnection; + + //set throughput infomation + throughput_upstream.low = srv.throughput_upstream; + throughput_downstream.low = srv.throughput_downstream; + qos_upstream.low = srv.qos_upstream; + qos_downstream.low = srv.qos_downstream; + + //set session infomation + pool_session_count = (*it)->get_pool_sessions_count(); + active_session_count = (*it)->get_active_sessions_count(); + waiting_session_count = (*it)->get_waiting_sessions_count(); + + //set vs table row infomation + netsnmp_set_row_column(row, COLUMN_L7VSVSINDEX, ASN_INTEGER, (char *)&vs_index, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSPROTOCOL, ASN_INTEGER, (char *)&protocol, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSADDRTYPE, ASN_INTEGER, (char *)&vs_ipaddress_type, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSADDR, ASN_OCTET_STR, vs_ipaddress, strnlen(vs_ipaddress, L7VS_IPADDR_LEN)); + netsnmp_set_row_column(row, COLUMN_L7VSVSPORT, ASN_UNSIGNED, (char *)&vs_port, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSPROTOCOLMODULENAME, ASN_OCTET_STR, (char *)srv.protocol_module_name.c_str(), srv.protocol_module_name.length()); + netsnmp_set_row_column(row, COLUMN_L7VSVSPROTOCOLMODULEOPTIONS, ASN_OCTET_STR, (char *)protocol_module_arg.str().c_str(), protocol_module_arg.str().length()); + netsnmp_set_row_column(row, COLUMN_L7VSVSSCHEDULEMODULENAME, ASN_OCTET_STR, (char *)srv.schedule_module_name.c_str(), srv.schedule_module_name.length()); + netsnmp_set_row_column(row, COLUMN_L7VSVSSCHEDULEMODULEOPTIONS, ASN_OCTET_STR, (char *)schedule_module_arg.c_str(), schedule_module_arg.length()); + netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYADDRTYPE, ASN_INTEGER, (char *)&sorry_ipaddress_type,sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYADDR, ASN_OCTET_STR, (char *)sorry_ipaddress, strnlen(sorry_ipaddress, L7VS_IPADDR_LEN)); + netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYPORT, ASN_INTEGER, (char *)&sorry_port, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYCONNLIMIT, ASN_COUNTER64, (char *)&sorry_maxconnection, sizeof(struct counter64)); + netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYFORCEENABLED, ASN_INTEGER, (char *)&srv.sorry_flag, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTUP, ASN_COUNTER64, (char *)&throughput_upstream, sizeof(struct counter64)); + netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTDOWN, ASN_COUNTER64, (char *)&throughput_downstream, sizeof(struct counter64)); + netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTUPQOS, ASN_COUNTER64, (char *)&qos_upstream, sizeof(struct counter64)); + netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTDOWNQOS, ASN_COUNTER64, (char *)&qos_downstream, sizeof(struct counter64)); + netsnmp_set_row_column(row, COLUMN_L7VSVSSSLFLAG, ASN_INTEGER, (char *)&ssl_flag, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSSESSIONPOOLCOUNT, ASN_INTEGER, (char *)&pool_session_count, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSSESSIONACTIVECOUNT, ASN_INTEGER, (char *)&active_session_count, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSSESSIONWAITCOUNT, ASN_INTEGER, (char *)&waiting_session_count, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSVSHTTPTOTALCOUNT, ASN_COUNTER64, (char *)&http_requests, sizeof(struct counter64)); + netsnmp_set_row_column(row, COLUMN_L7VSVSHTTPGETCOUNT, ASN_COUNTER64, (char *)&http_get_requests, sizeof(struct counter64)); + netsnmp_set_row_column(row, COLUMN_L7VSVSHTTPPOSTCOUNT, ASN_COUNTER64, (char *)&http_post_requests, sizeof(struct counter64)); + netsnmp_set_row_column(row, COLUMN_L7VSVSRSNUMBER, ASN_INTEGER, (char *)&rs_size, sizeof(size_t)); + + //create temporary realserver data list + int rs_index = 0; + for (std::vector::iterator rs_it = srv.realserver_vector.begin(); + rs_it != srv.realserver_vector.end(); rs_it++) { + rsdata data; + + //set realserver infomation + if (srv.udpmode) { + if ((*rs_it).udp_endpoint.address().is_v4()) { + strncpy(data.address, (*rs_it).udp_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN); + data.address_type = 1; + } else { + strncpy(data.address,(*rs_it).udp_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN); + data.address_type = 2; + } + data.port = (*rs_it).udp_endpoint.port(); + } else { + if ((*rs_it).tcp_endpoint.address().is_v4()) { + strncpy(data.address, (*rs_it).tcp_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN); + data.address_type = 1; + } else { + strncpy(data.address, (*rs_it).tcp_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN); + data.address_type = 2; + } + data.port = (*rs_it).tcp_endpoint.port(); + } + + data.index = rs_index; + data.vs_index = vs_index; + data.forward = 1; + data.weigth = (*rs_it).weight; + data.active_conn = (*rs_it).get_active(); + data.inactive_conn = (*rs_it).get_inact(); + + //push into realserver data list + rs_vector.push_back(data); + rs_index++; + } + vs_index++; + } + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "function : mibdata::update_vs_table : vs_table_size="; + debugstr << vs_table_size; + + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 66, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + //update realserver infomation with temporary realserver data list + update_rs_table(rs_vector, err); + } + + /*! + * update real server table infomation. + * + * @param const std::vector & temporary real server list + * @param error_code & error code + * @retrun void + */ + void mibdata::update_rs_table(const std::vector& rs_table_tmp, error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 67, "mibdata::update_rs_table", __FILE__, __LINE__); + + oid index[1] = {0}; + int rs_index = 0; + netsnmp_table_row *row = NULL; + + //delete the surplus data from real server table + if (rs_table_tmp.size() < static_cast(rs_table_size)) { + for (size_t i = rs_table_size; i > rs_table_tmp.size(); i--) { + index[0] = i; + row = netsnmp_table_data_get_from_oid(rs_table->table, index, 1); + if (row) continue; + netsnmp_table_dataset_remove_and_delete_row(rs_table, row); + } + } + + rs_table_size = rs_table_tmp.size(); + + //update real server table + for (std::vector::const_iterator itr = rs_table_tmp.begin(); itr != rs_table_tmp.end(); itr++) { + index[0] = rs_index; + row = netsnmp_table_data_get_from_oid(rs_table->table, index, 1); + if (row == NULL) { + row = netsnmp_create_table_data_row(); + if (row == NULL) { + std::string msg("create realserver table row failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 14, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return ; + } else { + netsnmp_table_row_add_index(row, ASN_INTEGER, (void*)index, sizeof(int)); + netsnmp_table_dataset_add_row(rs_table, row); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "function : mibdata::update_rs_table : rs_table add row."; + boost::format("rs_index=%d") % (*itr).index; + + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 68, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + } + } + + netsnmp_set_row_column(row, COLUMN_L7VSRSINDEX, ASN_INTEGER, (char *)&(*itr).index, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSRSVSINDEX, ASN_INTEGER, (char *)&(*itr).vs_index, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSRSADDRTYPE, ASN_INTEGER, (char *)&(*itr).address_type, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSRSADDR, ASN_OCTET_STR, (*itr).address, strlen((*itr).address)); + netsnmp_set_row_column(row, COLUMN_L7VSRSPORT, ASN_UNSIGNED, (char *)&(*itr).port, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSRSFORWARD, ASN_INTEGER, (char *)&(*itr).forward, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSRSWEIGHT, ASN_INTEGER, (char *)&(*itr).weigth, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSRSACTIVECONN, ASN_INTEGER, (char *)&(*itr).active_conn, sizeof(int)); + netsnmp_set_row_column(row, COLUMN_L7VSRSINACTIVECONN, ASN_INTEGER, (char *)&(*itr).inactive_conn, sizeof(int)); + + rs_index++; + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "function : mibdata::update_rs_table : rs_table_size="; + debugstr << rs_table_size; + + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 69, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + } + + /*! + * update replication state. + * + * @param l7vsd * l7vsd pointer + * @param error_code & error code + * @retrun void + */ + void mibdata::update_replication_state(l7vsd *in_vsd , error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 70, "mibdata::update_replication_state", __FILE__, __LINE__); + + if (in_vsd == NULL) { + std::string msg("in_vsd pointer is NULL."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 15, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "mibdata::update_replication_state arguments:"; + debugstr << boost::format("in_vsd=%p") % in_vsd; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 71, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + replication::REPLICATION_MODE_TAG state = in_vsd->get_replication_state(); + replication_state = static_cast(state); + } + + /*! + * get mibdata instance. + * + * @retrun mibdata instance + */ + mibdata& mibdata::get_instance() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 72, "mibdata::get_instance", __FILE__, __LINE__); + static mibdata data; + return data; + } + + /*! + * collect mibdata in l7vsd. + * + * @param l7vsd * l7vsd pointer + * @param error_code & error code + * @retrun void + */ + void mibdata::collect_mibdata(l7vsd *in_vsd, error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 73, "mibdata::collect_mibdata", __FILE__, __LINE__); + + if (in_vsd == NULL) { + std::string msg("in_vsd pointer is NULL."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 16, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + update_replication_state(in_vsd, err); + + if (err) { + std::string msg("update replication state failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 17, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + update_vs_table(in_vsd, err); + + if (err) { + std::string msg("update virtual service table failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 18, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + } + + /*! + * set virtual service data set. + * + * @param netsnmp_table_data_set * virtual service data set + * @retrun void + */ + void mibdata::set_vs_table(netsnmp_table_data_set* in_vs_table) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 74, "mibdata::set_vs_table", __FILE__, __LINE__); + vs_table = in_vs_table; + } + + /*! + * set real server data set. + * + * @param netsnmp_table_data_set * real server data set + * @retrun void + */ + void mibdata::set_rs_table(netsnmp_table_data_set* in_rs_table) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 75, "mibdata::set_rs_table", __FILE__, __LINE__); + rs_table = in_rs_table; + } +} diff --git a/l7vsd/src/snmpagent.cpp b/l7vsd/src/snmpagent.cpp new file mode 100644 index 00000000..24817d6c --- /dev/null +++ b/l7vsd/src/snmpagent.cpp @@ -0,0 +1,244 @@ +/*! + * @file snmpagent.cpp + * @brief snmpagent function class + * + * L7VSD: Linux Virtual Server for Layer7 Load Balancing + * Copyright (C) 2010 NTT COMWARE Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + **********************************************************************/ + +#include "snmpagent.h" + +namespace l7vs +{ + + /*! + * constructor. + * + * @param[in] l7vsd pointer + */ + snmpagent::snmpagent(l7vsd *in_vsd) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 1, "snmpagent::snmpagent", __FILE__, __LINE__); + + error_code err; + snmpagent_impl::get_instance().init(err); + if (err) { + std::string msg("snmpagent initialize failed.program exit."); + Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 1, msg, __FILE__, __LINE__); + exit(1); + } + snmpagent_impl::get_instance().set_vsd_info(in_vsd); + } + + /*! + * push the trap message into trap message queue. + * + * @param[in] in_trapmessage is trap message + * @param[in/out] err is error code + * @retrun void + */ + void snmpagent::push_trapmessage(trapmessage& in_trapmessage, error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 2, "snmpagent::push_trapmessage", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpagent::push_trapmessage arguments:"; + debugstr << boost::format("in_trapmessage.type=%d") % in_trapmessage.type; + debugstr << boost::format("in_trapmessage.message=%s") % in_trapmessage.message; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 3, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + snmpagent_impl::get_instance().push_trapmessage(in_trapmessage, err); + } + + /*! + * set snmp function enable + * + * @retrun void + */ + void snmpagent::enable() { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 4, "snmpagent::enable", __FILE__, __LINE__); + + snmpagent_impl::get_instance().enable(); + } + + /*! + * set snmp function disable + * + * @retrun void + */ + void snmpagent::disable() { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 5, "snmpagent::disable", __FILE__, __LINE__); + + snmpagent_impl::get_instance().enable(); + } + + /*! + * set mib cache update interval. + * + * @param[in] in_interval is cache update interval + * @retrun void + */ + void snmpagent::set_interval(const unsigned int in_interval) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 6, "snmpagent::set_interval", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpagent::set_interval arguments:"; + debugstr << boost::format("in_interval=%d") % in_interval; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 7, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + snmpagent_impl::get_instance().set_interval(in_interval); + } + + /*! + * set log trap enable + * @retrun void + */ + void snmpagent::logtrap_enable() { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 8, "snmpagent_impl::logtrap_enable", __FILE__, __LINE__); + + snmpagent_impl::get_instance().logtrap_enable(); + } + + /*! + * set log trap disable + * @retrun void + */ + void snmpagent::logtrap_disable() { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 9, "snmpagent_impl::logtrap_disable", __FILE__, __LINE__); + + snmpagent_impl::get_instance().logtrap_disable(); + } + + /*! + * set log trap level. + * + * @param[in] in_level is log trap level + * @retrun void + */ + void snmpagent::set_logtrap_level(const LOG_LEVEL_TAG in_level) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 10, "snmpagent::set_logtrap_level", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpagent::set_logtrap_level arguments:"; + debugstr << boost::format("in_level=%d") % in_level; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 11, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + snmpagent_impl::get_instance().set_logtrap_level(in_level); + } + + /*! + * get snmp infomation. + * + * @return snmp infomation + */ + snmp_info snmpagent::get_snmp_info() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 12, "snmpagent::get_snmp_info", __FILE__, __LINE__); + + return snmpagent_impl::get_instance().get_snmp_info(); + } + + /*! + * start snmp function. + * + * @param[in/out] error_code is error code + * @return void + */ + void snmpagent::start(error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 13, "snmpagent::start", __FILE__, __LINE__); + snmpagent_impl::get_instance().start(err); + } + + /*! + * stop snmp function. + * + * @return void + */ + void snmpagent::stop() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 14, "snmpagent::stop", __FILE__, __LINE__); + snmpagent_impl::get_instance().stop(); + } + + /*! + * refresh all the statistics. + * + * @return void + */ + void snmpagent::refresh_all_statistics() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 15, "snmpagent::refresh_all_statistics", __FILE__, __LINE__); + snmpagent_impl::get_instance().refresh_all_statistics(); + } + + /*! + * refresh a special virtual service's statistics. + * + * @param[in] vs_endpoint is virtual service's endpoint + * @param[in] protocol is virtual service's protocol + * @return void + */ + void snmpagent::refresh_statistics(const boost::asio::ip::tcp::endpoint& vs_endpoint, const std::string& protocol) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 16, "snmpagent::refresh_statistics", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpagent::refresh_statistics arguments:"; + if (vs_endpoint.address().is_v6()) { + debugstr << boost::format("vs_endpoint=[%s]:%d") % vs_endpoint.address().to_string() % vs_endpoint.port(); + } else { + debugstr << boost::format("vs_endpoint=%s:%d") % vs_endpoint.address().to_string() % vs_endpoint.port(); + } + debugstr << boost::format("protocol=%s") % protocol; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 17, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + snmpagent_impl::get_instance().refresh_statistics(vs_endpoint, protocol); + } + + /*! + * finalize. + * + * @return void + */ + void snmpagent::finalize() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 18, "snmpagent::finalize", __FILE__, __LINE__); + + snmpagent_impl::get_instance().finalize(); + } + +} diff --git a/l7vsd/src/snmpagent_impl.cpp b/l7vsd/src/snmpagent_impl.cpp new file mode 100644 index 00000000..fd30a140 --- /dev/null +++ b/l7vsd/src/snmpagent_impl.cpp @@ -0,0 +1,990 @@ +/*! + * @file snmpagent_impl.cpp + * @brief snmpagent implement module. + * + * L7VSD: Linux Virtual Server for Layer7 Load Balancing + * Copyright (C) 2010 NTT COMWARE Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + **********************************************************************/ + +#include "l7vsd.h" +#include "snmpagent_impl.h" +#include "mibdata.h" +#include "protocol_module_base.h" +#include "snmpfunc.h" + +#define SNMP_SLEEP_NANO_TIME (1000000) +#define SNMP_MAX_TRAP_POLLING_INTEVAL (1000000000) +#define SNMP_DEFAULT_TRAP_POLLING_INTEVAL (100000000) +#define SNMP_DEFAULT_TRAP_QUEUE_MAX_SIZE (1000) +#define TRAP_TIME_STRING_MAX_SIZE (20) + +#ifndef FALSE +#define FALSE (0) +#endif +#ifndef TRUE +#define TRUE (1) +#endif + +namespace l7vs +{ + + /*! + * process mib get item thread function. + * @retrun void + */ + void snmpagent_impl::process_mib_run() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 19, "snmpagent_impl::process_mib_run", __FILE__, __LINE__); + + //create wait time + timespec wait_val; + wait_val.tv_sec = 0; + wait_val.tv_nsec = SNMP_SLEEP_NANO_TIME; + + //main loop + while (enabled.get() != FALSE) { + //agent check and process + agent_check_and_process(0); + + //sleep a little time + nanosleep(&wait_val, NULL); + } + } + + /*! + * process trap thread function. + * @retrun void + */ + void snmpagent_impl::trap_run() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 20, "snmpagent_impl::trap_run", __FILE__, __LINE__); + + //create wait time + timespec wait_val; + wait_val.tv_sec = 0; + wait_val.tv_nsec = trap_polling_interval.get(); + + //main loop + while (enabled.get() != FALSE) { + //create trap message + trapmessage trapmsg; + { + boost::mutex::scoped_lock lock(trap_msg_queue_condition_mutex); + + //loop until the trap message is not none + while (trap_msg_queue.size() == 0) { + trap_msg_queue_condition.wait(lock); + } + + //get the first message in trap message + trapmsg = trap_msg_queue[0]; + + //pop the first message in trap message + trap_msg_queue.pop_front(); + } + + //find mapping in trap message map + trapfunc_type::iterator it = trapfunc_map.find(trapmsg.type); + + if (it != trapfunc_map.end()) { + //send trap message + it->second(trapmsg.message); + + //set trap last date to current time + trap_last_date = time(NULL); + + //increment snmp trap count + snmp_trap_count++; + } + + //sleep a little time + nanosleep(&wait_val, NULL); + } + } + + /*! + * check mib data timeout. + * @retrun true: time not out + * false: time out + */ + bool snmpagent_impl::check_timeout() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 21, "snmpagent::check_timeout", __FILE__, __LINE__); + + if (interval.get() == 0) { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::check_timeout : timeout."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 22, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + //when interval is 0, return false(timeout) + return false; + } else { + //get current time + boost::posix_time::ptime now_time(boost::posix_time::second_clock::universal_time()); + + //calc time interval + boost::posix_time::time_duration td = boost::posix_time::seconds(interval.get()); + + if ((now_time - mib_collect_last_time) > td) { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::check_timeout : timeout."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 23, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + //timeout + return false; + } else { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::check_timeout : not timeout."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 24, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + //not timeout + return true; + } + } + } + + /*! + * create and return a snmpagent_impl instance. + * + * @retrun snmpagent_impl & snmpagent_impl' instance + */ + snmpagent_impl& snmpagent_impl::get_instance() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 25, "snmpagent::get_instance", __FILE__, __LINE__); + + static snmpagent_impl agent_impl; + return agent_impl; + } + + /*! + * snmpagent_impl class initialize. + * + * @param error_code & error code + * @retrun void + */ + void snmpagent_impl::init(error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 26, "snmpagent_impl::init", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpagent_impl::init arguments:"; + debugstr << boost::format("err=%d") % (err ? true : false); + debugstr << boost::format("err.message=%s") % err.get_message(); + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 27, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + try { + if (initialized == false) { + //set snmp start flag false + start_flag = false; + + //mapping trap type and trap function + trapfunc_map[trapmessage::SERVICE_START] = &trap_service_start; + trapfunc_map[trapmessage::SERVICE_STOP] = &trap_service_stop; + trapfunc_map[trapmessage::VIRTUALSERVICE_ADD] = &trap_vs_add; + trapfunc_map[trapmessage::VIRTUALSERVICE_CHANGE] = &trap_vs_change; + trapfunc_map[trapmessage::VIRTUALSERVICE_REMOVE] = &trap_vs_remove; + trapfunc_map[trapmessage::REALSERVER_ADD] = &trap_rs_add; + trapfunc_map[trapmessage::REALSERVER_CHANGE] = &trap_rs_change; + trapfunc_map[trapmessage::REALSERVER_REMOVE] = &trap_rs_remove; + trapfunc_map[trapmessage::UPQOS_ALERT_ON] = &trap_up_qos_alert_on; + trapfunc_map[trapmessage::UPQOS_ALERT_OFF] = &trap_up_qos_alert_off; + trapfunc_map[trapmessage::DOWNQOS_ALERT_ON] = &trap_down_qos_alert_on; + trapfunc_map[trapmessage::DOWNQOS_ALERT_OFF] = &trap_down_qos_alert_off; + trapfunc_map[trapmessage::SESSIONPOOL_ALERT_ON] = &trap_sessionpool_alert_on; + trapfunc_map[trapmessage::SESSIONPOOL_ALERT_OFF] = &trap_sessionpool_alert_off; + trapfunc_map[trapmessage::FATAL_LOG] = &trap_fatal; + trapfunc_map[trapmessage::ERROR_LOG] = &trap_error; + trapfunc_map[trapmessage::WARN_LOG] = &trap_warn; + trapfunc_map[trapmessage::INFO_LOG] = &trap_info; + trapfunc_map[trapmessage::DEBUG_LOG] = &trap_debug; + + //init member varable + mib_collect_last_time = boost::posix_time::ptime(boost::posix_time::min_date_time); + start_date = 0; + request_last_date = 0; + trap_last_date = 0; + snmp_get_requests = 0; + snmp_set_requests = 0; + snmp_trap_count = 0; + + //mapping log string and log level + string_loglevel_map["debug"] = LOG_LV_DEBUG; + string_loglevel_map["info"] = LOG_LV_INFO; + string_loglevel_map["warn"] = LOG_LV_WARN; + string_loglevel_map["error"] = LOG_LV_ERROR; + string_loglevel_map["fatal"] = LOG_LV_FATAL; + + //load config file setting + load_config(); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::init : call load_config()."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 28, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_ds_set_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE, 1); + + //socket startup + SOCK_STARTUP; + + //init l7vsAgent + int ret = init_agent("l7vsAgent"); + if (ret) { + std::string msg("init_agent failed."); + Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 3, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + init_snmp("l7vsAgent"); + + //regist snmp get item' handle + init_snmp_handles(err); + + if (err) { + return; + } + + //set initializ flag true + initialized = true; + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::init : initialize success."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 29, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + } + } catch (const std::exception &e) { + std::stringstream msg; + msg << "init failed : " << e.what() << "."; + Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 2, msg.str(), __FILE__, __LINE__); + } + } + + /*! + * push the trap message into trap message queue. + * + * @param[in] in_trapmessage is trap message + * @param[in/out] err is error code + * @retrun void + */ + void snmpagent_impl::push_trapmessage(trapmessage& trapmessage, error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 30, "snmpagent_impl::push_trapmessage", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpagent_impl::push_trapmessage arguments:"; + debugstr << boost::format("trapmessage.type=%d") % trapmessage.type; + debugstr << boost::format("trapmessage.message=%s") % trapmessage.message; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 31, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + try { + //snmp function is enable + if ((start_flag == true) && (enabled.get() == TRUE)) { + //get local time string + char time_buf[TRAP_TIME_STRING_MAX_SIZE] = {0}; + time_t now = time(NULL); + struct tm *t = localtime(&now); + if (t) strftime(time_buf, sizeof(time_buf), "%Y/%m/%d %H:%M:%S", t); + //time string added in trap message + std::stringstream trap_buf; + trap_buf << time_buf << "," << trapmessage.message; + + if (trapmessage.type < trapmessage::DEBUG_LOG) { + char buff[HOST_NAME_MAX] = {0}; + gethostname(buff, HOST_NAME_MAX); + trap_buf << "," << buff; + } + + trapmessage.message = trap_buf.str(); + + { + boost::mutex::scoped_lock lock(trap_msg_queue_condition_mutex); + + //drap the message when the trap message queue is too large + if( trap_msg_queue.size() <= trap_queue_max_size.get()) + { + //push the message into trap message queue + trap_msg_queue.push_back(trapmessage); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "function : snmpagent_impl::push_trapmessage : trap message push back."; + debugstr << boost::format("trapmessage.type=%d") % trapmessage.type; + debugstr << boost::format("trapmessage.message=%s") % trapmessage.message; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 32, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + } + else{ + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::push_trapmessage : trap message queue is overflow."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 33, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + } + } + + //notify the trap main thread to process the message + trap_msg_queue_condition.notify_one(); + + } + } + catch (const std::exception &e) { + std::stringstream msg; + msg << "Push trap message failed : " << e.what() << "."; + + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 1, msg.str(), __FILE__, __LINE__); + //set error code + err.setter(true, msg.str()); + } + + } + + /*! + * snmpagent function start. + * + * @param[in/out] error_code is error code + * @retrun void + */ + void snmpagent_impl::start(error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 34, "snmpagent_impl::start", __FILE__, __LINE__); + + if (vsd == NULL) { + //vsd pointer is NULL + std::string msg("vsd pointer is NULL."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 2, msg, __FILE__, __LINE__); + err.setter(false, msg); + return; + } + + //check snmp enable state + if (enabled.get() == FALSE) { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::start : snmp function was disabled."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 35, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + return; + } + + //check start state + if (start_flag) { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::start : snmp function has already started."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 36, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + return; + } + + try { + //collect mib data first time + mibdata::get_instance().collect_mibdata(vsd, err); + + if (err) { + //mib collect failed + std::string msg("thread start failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 3, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + //start process mib run thread + process_mib_thread = boost::thread(&snmpagent_impl::process_mib_run, this); + + //start trap run + trap_thread = boost::thread(&snmpagent_impl::trap_run, this); + + //set start time and start flag + start_date = time(NULL); + start_flag = true; + + std::string str = "snmp function start."; + Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 1, str, __FILE__, __LINE__); + + } catch (const boost::thread_resource_error &e) { + std::stringstream msg; + msg << "snmp function start failed : " << e.what() << "."; + + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 4, msg.str(), __FILE__, __LINE__); + //set error code + err.setter(true, msg.str()); + } + } + + /*! + * snmpagent function stop. + * + * @retrun void + */ + void snmpagent_impl::stop() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 37, "snmpagent_impl::stop", __FILE__, __LINE__); + + enabled = FALSE; + + if (!start_flag) { + std::string str = "snmp function has already stoped."; + Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 2, str, __FILE__, __LINE__); + return; + } + + start_flag = false; + + try { + trap_thread.interrupt(); + process_mib_thread.join(); + trap_thread.join(); + + std::string str = "snmp function stop."; + Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 3, str, __FILE__, __LINE__); + + } catch (const boost::thread_interrupted&) { + std::stringstream msg; + msg << "thread interrupted exception."; + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 5, msg.str(), __FILE__, __LINE__); + } + } + + /*! + * set snmp function enable + * + * @retrun void + */ + void snmpagent_impl::enable() { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 38, "snmpagent_impl::enable", __FILE__, __LINE__); + + //set snmp function enable flag + enabled = TRUE; + if (start_flag == false) { + error_code err; + start(err); + + if (err) { + std::stringstream msg; + msg << "snmp function start failed."; + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 6, msg.str(), __FILE__, __LINE__); + } + } + else { + std::string str = "snmp function has already started."; + Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 4, str, __FILE__, __LINE__); + } + } + + /*! + * set snmp function disable + * + * @retrun void + */ + void snmpagent_impl::disable() { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 39, "snmpagent_impl::disable", __FILE__, __LINE__); + + //set snmp function enable flag + enabled = FALSE; + if (start_flag == true) { + stop(); + } + else { + std::string str = "snmp function has already stoped."; + Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 5, str, __FILE__, __LINE__); + } + } + + /*! + * set log trap enable + * @retrun void + */ + void snmpagent_impl::logtrap_enable() { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 40, "snmpagent_impl::logtrap_enable", __FILE__, __LINE__); + + logtrap_enabled = TRUE; + Logger::logtrap_enable(); + } + + /*! + * set log trap disable + * @retrun void + */ + void snmpagent_impl::logtrap_disable() { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 41, "snmpagent_impl::logtrap_disable", __FILE__, __LINE__); + + logtrap_enabled = FALSE; + Logger::logtrap_disable(); + } + + /*! + * set log trap level. + * + * @param[in] in_level is log trap level + * @retrun void + */ + void snmpagent_impl::set_logtrap_level(const LOG_LEVEL_TAG in_level) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 42, "snmpagent_impl::set_logtrap_level", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpagent_impl::set_logtrap_level arguments:"; + debugstr << boost::format("in_level=%d") % in_level; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 43, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + logtrap_level = in_level; + Logger::set_logtrap_level(in_level); + } + + /*! + * set mib cache update interval. + * + * @param[in] in_interval is cache update interval + * @retrun void + */ + void snmpagent_impl::set_interval(const unsigned int in_interval) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 44, "snmpagent_impl::set_interval", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpagent_impl::set_interval arguments:"; + debugstr << boost::format("in_interval=%d") % in_interval; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 45, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + interval = in_interval; + } + + /*! + * refresh all the statistics. + * + * @return void + */ + void snmpagent_impl::refresh_all_statistics() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 46, "snmpagent_impl::refresh_all_statistics", __FILE__, __LINE__); + + if (vsd == NULL) { + //mib collect failed + std::string msg("vsd pointer is NULL."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 7, msg, __FILE__, __LINE__); + return; + } + + boost::mutex &virtualservice_list_mutex = vsd->get_virtualservice_list_mutex(); + + boost::mutex::scoped_lock lock(virtualservice_list_mutex); + + l7vsd::vslist_type &virtualservice_list = vsd->get_virtualservice_list(); + + for (l7vsd::vslist_type::iterator it = virtualservice_list.begin(); + it != virtualservice_list.end(); it++) { + + //clear real server inactive count + (*it)->clear_inact(); + protocol_module_base *protocol_module_ptr = (*it)->get_protocol_module(); + stats_base& bstats = protocol_module_ptr->get_stats(); + if ( bstats.get_mode() == stats_base::MODE_HTTP ) { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::refresh_all_statistics :" + "stats_base::MODE_HTTP mode virtual service."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 47, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + http_stats &hstats = static_cast(bstats); + hstats.http_requests = 0ULL; + hstats.http_get_requests = 0ULL; + hstats.http_post_requests = 0ULL; + } + } + } + + /*! + * refresh a special virtual service's statistics. + * + * @param[in] vs_endpoint is virtual service's endpoint + * @param[in] protocol is virtual service's protocol + * @return void + */ + void snmpagent_impl::refresh_statistics(const boost::asio::ip::tcp::endpoint& vs_endpoint, const std::string& protocol) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 48, "snmpagent_impl::refresh_statistics", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpagent_impl::refresh_statistics arguments:"; + if (vs_endpoint.address().is_v6()) { + debugstr << boost::format("vs_endpoint=[%s]:%d") % vs_endpoint.address().to_string() % vs_endpoint.port(); + } else { + debugstr << boost::format("vs_endpoint=%s:%d") % vs_endpoint.address().to_string() % vs_endpoint.port(); + } + debugstr << boost::format("protocol=%s") % protocol; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 49, debugstr.str(), __FILE__, __LINE__); + } + + if (vsd == NULL) { + //mib collect failed + std::string msg("vsd pointer is NULL."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 8, msg, __FILE__, __LINE__); + return; + } + + boost::mutex &virtualservice_list_mutex = vsd->get_virtualservice_list_mutex(); + + boost::mutex::scoped_lock lock(virtualservice_list_mutex); + l7vsd::vslist_type &virtualservice_list = vsd->get_virtualservice_list(); + + virtualservice_element in_vselement; + in_vselement.udpmode = 0; + in_vselement.protocol_module_name = protocol; + in_vselement.tcp_accept_endpoint = vs_endpoint; + + l7vsd::vslist_type::iterator it = vsd->search_vslist(in_vselement, true); + + if (it != virtualservice_list.end()) { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::refresh_statistics :" + "input virtual service has found."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 50, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + //clear real server inactive count + (*it)->clear_inact(); + + protocol_module_base *protocol_module_ptr = (*it)->get_protocol_module(); + stats_base& base_stats = protocol_module_ptr->get_stats(); + if ( base_stats.get_mode() == stats_base::MODE_HTTP ) { + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::string debugstr = "function : snmpagent_impl::refresh_statistics :" + "stats_base::MODE_HTTP mode virtual service."; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 51, debugstr, __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + http_stats &httpstats = static_cast(base_stats); + //clear http statstics + httpstats.http_requests = 0ULL; + httpstats.http_get_requests = 0ULL; + httpstats.http_post_requests = 0ULL; + + } + } + } + + /*! + * set vsd infomation. + * + * @param[in] vsd is vsd pointer. + * @retrun void + */ + void snmpagent_impl::set_vsd_info(l7vsd* in_vsd) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 52, "snmpagent_impl::set_vsd_info", __FILE__, __LINE__); + + vsd = in_vsd; + } + + /*! + * get snmp infomation. + * + * @retrun snmp_info is snmp infomation. + */ + snmp_info snmpagent_impl::get_snmp_info() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 53, "snmpagent_impl::get_snmp_info", __FILE__, __LINE__); + snmp_info snmpinfo; + + //push the local variable into snmp info + snmpinfo.enabled = enabled.get(); + snmpinfo.interval = interval.get(); + snmpinfo.logtrap_enabled = logtrap_enabled; + snmpinfo.logtrap_level = logtrap_level; + snmpinfo.request_last_date = request_last_date.get(); + snmpinfo.snmp_get_requests = snmp_get_requests.get(); + snmpinfo.snmp_set_requests = snmp_set_requests.get(); + snmpinfo.snmp_trap_count = snmp_trap_count.get(); + snmpinfo.start_date = start_date.get(); + snmpinfo.trap_last_date = trap_last_date.get(); + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::ostringstream debugstr; + debugstr << "function : snmpagent_impl::get_snmp_info : snmpinfo : "; + debugstr << snmpinfo << "."; + + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 54, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + return snmpinfo; + } + + /*! + * load configure file setting. + * + * @retrun void + */ + void snmpagent_impl::load_config() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 55, "snmpagent_impl::load_config", __FILE__, __LINE__); + l7vs::Parameter param; + l7vs::error_code err; + + std::string tmp_str = param.get_string(l7vs::PARAM_COMP_SNMPAGENT, "enable", err); + if (!err) { + if (tmp_str == "true") { + enabled = TRUE; + } else if (tmp_str == "false") { + enabled = FALSE; + } else { + enabled = FALSE; + std::string msg("enable parameter value is invalid. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 1, msg, __FILE__, __LINE__); + } + } else { + enabled = FALSE; + std::string msg("enable parameter not found. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 2, msg, __FILE__, __LINE__); + } + + int tmp_int = param.get_int(l7vs::PARAM_COMP_SNMPAGENT, "trap_queue_polling_interval", err); + + if (!err) { + if ((tmp_int > 0) && (tmp_int < SNMP_MAX_TRAP_POLLING_INTEVAL)) { + trap_polling_interval = tmp_int; + } else { + trap_polling_interval = SNMP_DEFAULT_TRAP_POLLING_INTEVAL; + std::string msg("trap_queue_polling_interval parameter value is invalid. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 3, msg, __FILE__, __LINE__); + } + } else { + trap_polling_interval = SNMP_DEFAULT_TRAP_POLLING_INTEVAL; + std::string msg("trap_queue_polling_interval parameter not found. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 4, msg, __FILE__, __LINE__); + } + + tmp_int = param.get_int(l7vs::PARAM_COMP_SNMPAGENT, "trap_queue_max_size", err); + if (!err) { + if (tmp_int > 0) { + trap_queue_max_size = tmp_int; + } else { + trap_queue_max_size = SNMP_DEFAULT_TRAP_QUEUE_MAX_SIZE; + std::string msg("trap_queue_max_size parameter value is invalid. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 5, msg, __FILE__, __LINE__); + } + } else { + trap_queue_max_size = SNMP_DEFAULT_TRAP_QUEUE_MAX_SIZE; + std::string msg("trap_queue_max_size parameter not found. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 6, msg, __FILE__, __LINE__); + } + + tmp_int = param.get_int(l7vs::PARAM_COMP_SNMPAGENT, "cache_update_interval", err); + if (!err) { + if (tmp_int >= 0) { + interval = tmp_int; + } else { + interval = 1; + std::string msg("cache_update_interval parameter value is invalid. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 7, msg, __FILE__, __LINE__); + } + } else { + interval = 1; + std::string msg("cache_update_interval parameter not found. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 8, msg, __FILE__, __LINE__); + } + + tmp_str = param.get_string(l7vs::PARAM_COMP_SNMPAGENT, "logtrap", err); + if (!err) { + if (tmp_str == "true") { + logtrap_enable(); + } else { + logtrap_disable(); + std::string msg("logtrap parameter value is invalid. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 9, msg, __FILE__, __LINE__); + } + } else { + logtrap_disable(); + std::string msg("logtrap parameter not found. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 10, msg, __FILE__, __LINE__); + } + + tmp_str = param.get_string(l7vs::PARAM_COMP_SNMPAGENT, "logtrap_level", err); + if (!err) { + string_loglevel_map_type::iterator itr = string_loglevel_map.find(tmp_str); + if (itr != string_loglevel_map.end()) { + set_logtrap_level(itr->second); + } else { + set_logtrap_level( LOG_LV_WARN); + std::string msg("logtrap_level parameter value is invalid. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 11, msg, __FILE__, __LINE__); + } + } else { + set_logtrap_level(LOG_LV_WARN); + std::string msg("logtrap_level parameter not found. Use default value."); + Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 12, msg, __FILE__, __LINE__); + } + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "function : snmpagent_impl::load_config : "; + debugstr << "enabled = [" << enabled.get() << "], "; + debugstr << "interval = [" << interval.get() << "], "; + debugstr << "logtrap_enabled = [" << logtrap_enabled << "], "; + debugstr << "logtrap_level = [" << static_cast(logtrap_level) << "], "; + debugstr << "trap_polling_interval = [" << trap_polling_interval.get() << "], "; + debugstr << "trap_queue_max_size = [" << trap_queue_max_size.get() << "]. "; + + Logger::putLogDebug(l7vs::LOG_CAT_L7VSD_SNMPAGENT, 56, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + } + + /*! + * collect mib data. + * + * @param[in] error_code is err code. + * @retrun void + */ + void snmpagent_impl::collect_mibdata(error_code& err) + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 57, "snmpagent_impl::collect_mibdata", __FILE__, __LINE__); + + //check vsd pointer + if (vsd == NULL) { + std::string msg("vsd pointer is NULL."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 9, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + //check timeout + if (!check_timeout()) { + + //collect mib data + mibdata::get_instance().collect_mibdata(vsd, err); + + if (err) { + std::string msg("collect mib data failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 10, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + boost::posix_time::ptime now_time(boost::posix_time::second_clock::local_time()); + mib_collect_last_time = now_time; + + } + + //update last request date + request_last_date = time(NULL); + } + + /*! + * finalize. + * + * @retrun void + */ + void snmpagent_impl::finalize() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 58, "snmpagent_impl::finalize", __FILE__, __LINE__); + + if (start_flag == true) { + stop(); + } + snmp_shutdown("l7vsAgent"); + SOCK_CLEANUP; + } + + /*! + * increment get request count. + * + * @retrun void + */ + void snmpagent_impl::increment_getrequest_count() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 59, "snmpagent_impl::increment_getrequest_count", __FILE__, __LINE__); + snmp_get_requests++; + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::ostringstream debugstr; + debugstr << "function : snmpagent_impl::increment_getrequest_count : snmp_get_requests = "; + debugstr << snmp_get_requests.get() << "."; + + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 60, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + } + + /*! + * increment set request count. + * + * @retrun void + */ + void snmpagent_impl::increment_setrequest_count() + { + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 61, "snmpagent_impl::increment_setrequest_count", __FILE__, __LINE__); + snmp_set_requests++; + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::ostringstream debugstr; + debugstr << "function : snmpagent_impl::increment_getrequest_count : snmp_set_requests = "; + debugstr << snmp_set_requests.get() << "."; + + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 62, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + } + +} diff --git a/l7vsd/src/snmpfunc.cpp b/l7vsd/src/snmpfunc.cpp new file mode 100644 index 00000000..67771382 --- /dev/null +++ b/l7vsd/src/snmpfunc.cpp @@ -0,0 +1,1687 @@ +/*! + * @file snmpfunc.cpp + * @brief snmp function module. + * + * L7VSD: Linux Virtual Server for Layer7 Load Balancing + * Copyright (C) 2010 NTT COMWARE Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + **********************************************************************/ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.create-dataset.conf 17337 2009-01-01 14:28:29Z magfr $ + * : mib2c.scalar.conf 17337 2009-01-01 14:28:29Z magfr $ + * : mib2c.notify.conf 17455 2009-04-05 09:53:29Z magfr $ + */ +#include "mibdata.h" +#include "snmpagent_impl.h" +#include "snmpfunc.h" + +static const oid snmptrap_oid[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 }; +netsnmp_table_data_set *vs_table; +netsnmp_table_data_set *rs_table; + + +/*! + * initialize snmp scaler and table data set handles. + * + * @param[in] error_code& is trap error code + * @retrun void + */ +void +init_snmp_handles(error_code& err) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 76, "snmpfunc::init_snmp_handles", __FILE__, __LINE__); + + oid l7vsVsNumber_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 1 }; + oid l7vsReplicationMode_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 4 }; + + DEBUGMSGTL(("ultramonkey_l7", "init_snmp_handles\n")); + + int ret = netsnmp_register_scalar(netsnmp_create_handler_registration + ("l7vsVsNumber", handle_get_vstable_count, + l7vsVsNumber_oid, + OID_LENGTH(l7vsVsNumber_oid), + HANDLER_CAN_RONLY)); + + if ( ret ) { + std::string msg("netsnmp_register_scalar failed."); + Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 4, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + ret = netsnmp_register_scalar(netsnmp_create_handler_registration + ("l7vsReplicationMode", + handle_get_rep_state, + l7vsReplicationMode_oid, + OID_LENGTH(l7vsReplicationMode_oid), + HANDLER_CAN_RONLY)); + + if (ret) { + std::string msg("netsnmp_register_scalar failed."); + Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 5, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + /* + * here we initialize all the tables we're planning on supporting + */ + initialize_virtual_service_table(err); + + if (ret) return; + + initialize_real_server_table(err); + + if (ret) return; +} + +/*! + * handle for virtual service count. + * + */ +int +handle_get_vstable_count(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 77, "snmpfunc::handle_get_vstable_count", __FILE__, __LINE__); + /* + * We are never called for a GETNEXT if it's registered as a + * "instance", as it's "magically" handled for us. + */ + + /* + * a instance handler also only hands us one request at a time, so + * we don't need to loop over a list of requests; we'll only get one. + */ + + switch (reqinfo->mode) { + + case MODE_GET: { + error_code err; + //collect mibdata + l7vs::snmpagent_impl::get_instance().collect_mibdata(err); + + if (err) { + std::string msg("collect mib data failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 19, msg, __FILE__, __LINE__); + + return SNMP_ERR_GENERR; + } + + //get virtual serveice size + int rep_state = l7vs::mibdata::get_instance().get_vs_table_size(); + + //set value + int ret = snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER, + (u_char *)&rep_state, + sizeof(int)); + + if (ret) { + std::string msg("snmp_set_var_typed_value failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 20, msg, __FILE__, __LINE__); + + return SNMP_ERR_GENERR; + } + + snmpagent_impl::get_instance().increment_getrequest_count(); + } + break; + default: + /* + * we should never get here, so this is a really bad error + */ + snmp_log(LOG_ERR, "unknown mode (%d) in handle_get_vstable_count\n", + reqinfo->mode); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} + +/*! + * handle for replication state. + * + */ +int +handle_get_rep_state(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 78, "snmpfunc::handle_get_rep_state", __FILE__, __LINE__); + + /* + * We are never called for a GETNEXT if it's registered as a + * "instance", as it's "magically" handled for us. + */ + + /* + * a instance handler also only hands us one request at a time, so + * we don't need to loop over a list of requests; we'll only get one. + */ + + switch (reqinfo->mode) { + + case MODE_GET: { + error_code err; + //collect mibdata + l7vs::snmpagent_impl::get_instance().collect_mibdata(err); + + if (err) { + std::string msg("collect mib data failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 21, msg, __FILE__, __LINE__); + + return SNMP_ERR_GENERR; + } + + //get replication state + int rep_state = l7vs::mibdata::get_instance().get_replication_state(); + + + //set value + int ret = snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER, + (u_char *)&rep_state, + sizeof(int)); + + if (ret) { + std::string msg("snmp_set_var_typed_value failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 22, msg, __FILE__, __LINE__); + + return SNMP_ERR_GENERR; + } + + snmpagent_impl::get_instance().increment_getrequest_count(); + } + break; + default: + /* + * we should never get here, so this is a really bad error + */ + snmp_log(LOG_ERR, + "unknown mode (%d) in handle_get_rep_state\n", + reqinfo->mode); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} + +/*! + * initialize virtual service table data set. + * + * @param[in] error_code& is trap error code + * @retrun void + */ +void +initialize_virtual_service_table(error_code &err) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 79, "snmpfunc::initialize_virtual_service_table", __FILE__, __LINE__); + + oid l7vsVsTable_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 2 }; + + /* + * create the table structure itself + */ + vs_table = netsnmp_create_table_data_set("l7vsVsTable"); + + if (!vs_table) { + std::string msg("netsnmp create l7vsVsTable data set failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 23, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + //set data set into mibdata + mibdata::get_instance().set_vs_table(vs_table); + + /* + * comment this out or delete if you don't support creation of new rows + */ + vs_table->allow_creation = 1; + + /*************************************************** + * Adding indexes + */ + DEBUGMSGTL(("initialize_virtual_service_table", + "adding indexes to table l7vsVsTable\n")); + netsnmp_table_set_add_indexes(vs_table, ASN_INTEGER, /* index: l7vsVsIndex */ + 0); + + DEBUGMSGTL(("initialize_virtual_service_table", + "adding column types to table l7vsVsTable\n")); + netsnmp_table_set_multi_add_default_row(vs_table, + COLUMN_L7VSVSINDEX, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSVSPROTOCOL, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSVSADDRTYPE, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSVSADDR, + ASN_OCTET_STR, 0, NULL, 0, + COLUMN_L7VSVSPORT, + ASN_UNSIGNED, 0, NULL, 0, + COLUMN_L7VSVSPROTOCOLMODULENAME, + ASN_OCTET_STR, 0, NULL, 0, + COLUMN_L7VSVSPROTOCOLMODULEOPTIONS, + ASN_OCTET_STR, 0, NULL, 0, + COLUMN_L7VSVSSCHEDULEMODULENAME, + ASN_OCTET_STR, 0, NULL, 0, + COLUMN_L7VSVSSCHEDULEMODULEOPTIONS, + ASN_OCTET_STR, 0, NULL, 0, + COLUMN_L7VSVSSORRYADDRTYPE, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSVSSORRYADDR, + ASN_OCTET_STR, 0, NULL, 0, + COLUMN_L7VSVSSORRYPORT, + ASN_UNSIGNED, 0, NULL, 0, + COLUMN_L7VSVSSORRYCONNLIMIT, + ASN_COUNTER64, 0, NULL, 0, + COLUMN_L7VSVSSORRYFORCEENABLED, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSVSTHROUGHPUTUP, + ASN_COUNTER64, 0, NULL, 0, + COLUMN_L7VSVSTHROUGHPUTDOWN, + ASN_COUNTER64, 0, NULL, 0, + COLUMN_L7VSVSTHROUGHPUTUPQOS, + ASN_COUNTER64, 0, NULL, 0, + COLUMN_L7VSVSTHROUGHPUTDOWNQOS, + ASN_COUNTER64, 0, NULL, 0, + COLUMN_L7VSVSSSLFLAG, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSVSSESSIONPOOLCOUNT, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSVSSESSIONACTIVECOUNT, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSVSSESSIONWAITCOUNT, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSVSHTTPTOTALCOUNT, + ASN_COUNTER64, 0, NULL, 0, + COLUMN_L7VSVSHTTPGETCOUNT, + ASN_COUNTER64, 0, NULL, 0, + COLUMN_L7VSVSHTTPPOSTCOUNT, + ASN_COUNTER64, 0, NULL, 0, + COLUMN_L7VSVSRSNUMBER, + ASN_INTEGER, 0, NULL, 0, 0); + + /* + * registering the table with the master agent + */ + /* + * note: if you don't need a subhandler to deal with any aspects + * of the request, change handle_get_vstable to "NULL" + */ + int ret = netsnmp_register_table_data_set(netsnmp_create_handler_registration + ("l7vsVsTable", handle_get_vstable, + l7vsVsTable_oid, + OID_LENGTH(l7vsVsTable_oid), + HANDLER_CAN_RWRITE), vs_table, NULL); + + if (ret) { + std::string msg("netsnmp create l7vsVsTable data set failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 24, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } +} + +/*! + * initialize real server table data set. + * + * @param[in] error_code& is trap error code + * @retrun void + */ +void +initialize_real_server_table(error_code &err) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 80, "snmpfunc::initialize_real_server_table", __FILE__, __LINE__); + + oid l7vsRsTable_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 3 }; + + /* + * create the table structure itself + */ + rs_table = netsnmp_create_table_data_set("l7vsRsTable"); + + if (!rs_table) { + std::string msg("netsnmp create l7vsRsTable data set failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 25, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + + //set data set into mibdata + mibdata::get_instance().set_rs_table(rs_table); + /* + * comment this out or delete if you don't support creation of new rows + */ + rs_table->allow_creation = 1; + + /*************************************************** + * Adding indexes + */ + DEBUGMSGTL(("initialize_real_server_table", + "adding indexes to table l7vsRsTable\n")); + netsnmp_table_set_add_indexes(rs_table, ASN_INTEGER, /* index: l7vsRsIndex */ + 0); + + DEBUGMSGTL(("initialize_real_server_table", + "adding column types to table l7vsRsTable\n")); + netsnmp_table_set_multi_add_default_row(rs_table, + COLUMN_L7VSRSINDEX, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSRSVSINDEX, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSRSADDRTYPE, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSRSADDR, + ASN_OCTET_STR, 0, NULL, 0, + COLUMN_L7VSRSPORT, + ASN_UNSIGNED, 0, NULL, 0, + COLUMN_L7VSRSFORWARD, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSRSWEIGHT, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSRSACTIVECONN, + ASN_INTEGER, 0, NULL, 0, + COLUMN_L7VSRSINACTIVECONN, + ASN_INTEGER, 0, NULL, 0, 0); + + /* + * registering the table with the master agent + */ + /* + * note: if you don't need a subhandler to deal with any aspects + * of the request, change handle_get_rstable to "NULL" + */ + int ret = netsnmp_register_table_data_set(netsnmp_create_handler_registration + ("l7vsRsTable", handle_get_rstable, + l7vsRsTable_oid, + OID_LENGTH(l7vsRsTable_oid), + HANDLER_CAN_RWRITE), rs_table, NULL); + + if (ret) { + std::string msg("netsnmp create l7vsRsTable data set failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 26, msg, __FILE__, __LINE__); + //set error code + err.setter(true, msg); + return; + } + +} + +/*! + * handle for virtual service table. + * + */ +int +handle_get_vstable(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 81, "snmpfunc::handle_get_vstable", __FILE__, __LINE__); + + /* + * perform anything here that you need to do. The requests have + * already been processed by the master table_dataset handler, but + * this gives you chance to act on the request in some other way + * if need be. + */ + error_code err; + //collect mibdata + l7vs::snmpagent_impl::get_instance().collect_mibdata(err); + + if (err) { + std::string msg("collect mib data failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 27, msg, __FILE__, __LINE__); + + return SNMP_ERR_GENERR; + } + + snmpagent_impl::get_instance().increment_getrequest_count(); + + return SNMP_ERR_NOERROR; +} + +/*! + * handle for real server table. + * + */ +int +handle_get_rstable(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 82, "snmpfunc::handle_get_rstable", __FILE__, __LINE__); + + /* + * perform anything here that you need to do. The requests have + * already been processed by the master table_dataset handler, but + * this gives you chance to act on the request in some other way + * if need be. + */ + error_code err; + //collect mibdata + l7vs::snmpagent_impl::get_instance().collect_mibdata(err); + + if (err) { + std::string msg("collect mib data failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 28, msg, __FILE__, __LINE__); + + return SNMP_ERR_GENERR; + } + + snmpagent_impl::get_instance().increment_getrequest_count(); + + return SNMP_ERR_NOERROR; +} + +/*! + * send service start trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_service_start(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 83, "snmpfunc::trap_service_start", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_service_start arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 84, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsServiceStart_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 1, 1 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, + OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsServiceStart_oid, + sizeof(l7vsServiceStart_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 29, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsServiceStart_oid, + OID_LENGTH(l7vsServiceStart_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 30, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send service stop trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_service_stop(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 85, "snmpfunc::trap_service_stop", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_service_stop arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 86, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsServiceStop_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 1, 2 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, + OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsServiceStop_oid, + sizeof(l7vsServiceStop_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 31, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsServiceStop_oid, + OID_LENGTH(l7vsServiceStop_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 32, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send virtual service add trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_vs_add(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 87, "snmpfunc::trap_vs_add", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_vs_add arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 88, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingVsAdd_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 1 }; + + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingVsAdd_oid, + sizeof(l7vsBalancingVsAdd_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 33, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingVsAdd_oid, + OID_LENGTH(l7vsBalancingVsAdd_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 34, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send virtual service change trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_vs_change(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 89, "snmpfunc::trap_vs_change", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_vs_change arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 90, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingVsChange_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 2 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingVsChange_oid, + sizeof(l7vsBalancingVsChange_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 35, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingVsChange_oid, + OID_LENGTH(l7vsBalancingVsChange_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 36, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send virtual service remove trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_vs_remove(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 91, "snmpfunc::trap_vs_remove", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_vs_remove arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 92, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingVsRemove_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 3 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingVsRemove_oid, + sizeof(l7vsBalancingVsRemove_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 37, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingVsRemove_oid, + OID_LENGTH(l7vsBalancingVsRemove_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 38, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send real server add trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_rs_add(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 93, "snmpfunc::trap_rs_add", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_rs_add arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 94, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingRsAdd_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 4 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingRsAdd_oid, + sizeof(l7vsBalancingRsAdd_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 39, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingRsAdd_oid, + OID_LENGTH(l7vsBalancingRsAdd_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 40, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send real server change trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_rs_change(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 95, "snmpfunc::trap_rs_change", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_rs_change arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 96, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingRsChange_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 5 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingRsChange_oid, + sizeof(l7vsBalancingRsChange_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 41, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingRsChange_oid, + OID_LENGTH(l7vsBalancingRsChange_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 42, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send real server remove trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_rs_remove(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 97, "snmpfunc::trap_rs_remove", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_rs_remove arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 98, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingRsRemove_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 6 }; + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingRsRemove_oid, + sizeof(l7vsBalancingRsRemove_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 43, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingRsRemove_oid, + OID_LENGTH(l7vsBalancingRsRemove_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 44, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send upstream QoS alert on trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_up_qos_alert_on(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 99, "snmpfunc::trap_up_qos_alert_on", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_up_qos_alert_on arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 100, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingUpQoSAlertOn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 7 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingUpQoSAlertOn_oid, + sizeof(l7vsBalancingUpQoSAlertOn_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 45, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingUpQoSAlertOn_oid, + OID_LENGTH(l7vsBalancingUpQoSAlertOn_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 46, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send upstream QoS alert off trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_up_qos_alert_off(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 101, "snmpfunc::trap_up_qos_alert_off", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_up_qos_alert_off arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 102, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingUpQoSAlertOff_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 8 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingUpQoSAlertOff_oid, + sizeof(l7vsBalancingUpQoSAlertOff_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 47, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingUpQoSAlertOff_oid, + OID_LENGTH(l7vsBalancingUpQoSAlertOff_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 48, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send downstream QoS alert on trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_down_qos_alert_on(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 103, "snmpfunc::trap_down_qos_alert_on", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_down_qos_alert_on arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 104, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingDownQoSAlertOn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 9 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingDownQoSAlertOn_oid, + sizeof(l7vsBalancingDownQoSAlertOn_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 49, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingDownQoSAlertOn_oid, + OID_LENGTH(l7vsBalancingDownQoSAlertOn_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 50, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send downstream QoS alert off trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_down_qos_alert_off(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 105, "snmpfunc::trap_down_qos_alert_off", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_down_qos_alert_off arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 106, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingDownQoSAlertOff_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 10 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingDownQoSAlertOff_oid, + sizeof(l7vsBalancingDownQoSAlertOff_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 51, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingDownQoSAlertOff_oid, + OID_LENGTH(l7vsBalancingDownQoSAlertOff_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 52, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send session pool alert on trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_sessionpool_alert_on(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 107, "snmpfunc::trap_sessionpool_alert_on", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_sessionpool_alert_on arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 108, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingSessionPoolAlertOn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 11 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingSessionPoolAlertOn_oid, + sizeof(l7vsBalancingSessionPoolAlertOn_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 53, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingSessionPoolAlertOn_oid, + OID_LENGTH(l7vsBalancingSessionPoolAlertOn_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 54, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send session pool alert off trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_sessionpool_alert_off(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 109, "snmpfunc::trap_sessionpool_alert_off", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_sessionpool_alert_off arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 110, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsBalancingSessionPoolAlertOff_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 12 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsBalancingSessionPoolAlertOff_oid, + sizeof + (l7vsBalancingSessionPoolAlertOff_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 55, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsBalancingSessionPoolAlertOff_oid, + OID_LENGTH(l7vsBalancingSessionPoolAlertOff_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 56, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send fatal log trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_fatal(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 111, "snmpfunc::trap_fatal", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_fatal arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 112, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsLogFatal_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 1 }; + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsLogFatal_oid, sizeof(l7vsLogFatal_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 57, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsLogFatal_oid, + OID_LENGTH(l7vsLogFatal_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 58, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send error log trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_error(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 113, "snmpfunc::trap_error", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_error arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 114, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsLogError_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 2 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsLogError_oid, sizeof(l7vsLogError_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 59, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsLogError_oid, + OID_LENGTH(l7vsLogError_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 60, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send warn log trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_warn(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 115, "snmpfunc::trap_warn", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_warn arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 116, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsLogWarn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 3 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsLogWarn_oid, sizeof(l7vsLogWarn_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 61, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsLogWarn_oid, + OID_LENGTH(l7vsLogWarn_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 62, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send info log trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_info(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 117, "snmpfunc::trap_info", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_info arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 118, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsLogInfo_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 4 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsLogInfo_oid, sizeof(l7vsLogInfo_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 63, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsLogInfo_oid, + OID_LENGTH(l7vsLogInfo_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 64, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} + +/*! + * send debug log trap. + * + * @param[in] std::string is trap message + * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR + */ +int +trap_debug(const std::string &in_trapmessage) +{ + Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 119, "snmpfunc::trap_debug", __FILE__, __LINE__); + + /*-------- DEBUG LOG --------*/ + if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) { + std::stringstream debugstr; + debugstr << "snmpfunc::trap_debug arguments:"; + debugstr << boost::format("in_trapmessage=%s") % in_trapmessage; + Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 120, debugstr.str(), __FILE__, __LINE__); + } + /*------ DEBUG LOG END ------*/ + + netsnmp_variable_list *var_list = NULL; + netsnmp_variable_list *ret_list = NULL; + oid l7vsLogDebug_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 5 }; + + /* + * Set the snmpTrapOid.0 value + */ + ret_list = snmp_varlist_add_variable(&var_list, + snmptrap_oid, OID_LENGTH(snmptrap_oid), + ASN_OBJECT_ID, + (u_char*)l7vsLogDebug_oid, sizeof(l7vsLogDebug_oid)); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 65, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + + ret_list = snmp_varlist_add_variable(&var_list, + l7vsLogDebug_oid, + OID_LENGTH(l7vsLogDebug_oid), + ASN_OCTET_STR, + (u_char*)in_trapmessage.c_str(), + in_trapmessage.length()); + if (!ret_list) { + std::string msg("snmp_varlist_add_variable failed."); + Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 66, msg, __FILE__, __LINE__); + return SNMP_ERR_GENERR; + } + /* + * Add any extra (optional) objects here + */ + + /* + * Send the trap to the list of configured destinations + * and clean up + */ + send_v2trap(var_list); + snmp_free_varbind(var_list); + + return SNMP_ERR_NOERROR; +} -- 2.11.0