l7vsd/src/mibdata.cpp

   1 /*!
   2  * @file  mibdata.cpp
   3  * @brief mibdata module.
   4  *
   5  * L7VSD: Linux Virtual Server for Layer7 Load Balancing
   6  * Copyright (C) 2010  NTT COMWARE Corporation.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  **********************************************************************/
  24 #include "mibdata.h"
  25 #include "snmpfunc.h"
  26
  27
  28 namespace l7vs
  29 {
  30         /*!
  31          * update virtual service table infomation.
  32          *
  33          * @param   l7vsd * l7vsd pointer
  34          * @param   error_code & error code
  35          * @retrun  void
  36          */
  37         void mibdata::update_vs_table(l7vsd *in_vsd, error_code&  err)
  38         {
  39                 Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 63, "mibdata::update_vs_table", __FILE__, __LINE__);
  40
  41                 if (in_vsd == NULL) {
  42                         std::string msg("in_vsd pointer is NULL.");
  43                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 11, msg, __FILE__, __LINE__);
  44                         //set error code
  45                         err.setter(true, msg);
  46                         return;
  47                 }
  48
  49                 if (vs_table == NULL) {
  50                         std::string msg("vs_table pointer is NULL.");
  51                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 12, msg, __FILE__, __LINE__);
  52                         //set error code
  53                         err.setter(true, msg);
  54                         return;
  55                 }
  56
  57                 /*-------- DEBUG LOG --------*/
  58                 if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
  59                         std::stringstream    debugstr;
  60                         debugstr << "mibdata::update_vs_table arguments:";
  61                         debugstr << boost::format("in_vsd=%p") % in_vsd;
  62                         Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 64, debugstr.str(), __FILE__, __LINE__);
  63                 }
  64                 /*------ DEBUG LOG END ------*/
  65
  66                 oid   index[1] = {0};
  67                 netsnmp_table_row *row = NULL;
  68                 int vs_index = 0;
  69                 std::vector<rsdata>  rs_vector;
  70
  71                 int protocol = 0;
  72                 char vs_ipaddress[L7VS_IPADDR_LEN] = {0};
  73                 char sorry_ipaddress[L7VS_IPADDR_LEN] = {0};
  74                 int vs_ipaddress_type = 1;
  75                 int sorry_ipaddress_type = 1;
  76                 int vs_port = 0;
  77                 int sorry_port = 0;
  78
  79                 struct counter64 sorry_maxconnection = {
  80                         0
  81                 };
  82                 struct counter64 throughput_upstream = {
  83                         0
  84                 };
  85                 struct counter64 throughput_downstream = {
  86                         0
  87                 };
  88                 struct counter64 qos_upstream = {
  89                         0
  90                 };
  91                 struct counter64 qos_downstream = {
  92                         0
  93                 };
  94                 struct counter64 http_requests = {
  95                         0
  96                 };
  97                 struct counter64 http_get_requests = {
  98                         0
  99                 };
 100                 struct counter64 http_post_requests = {
 101                         0
 102                 };
 103
 104                 int pool_session_count = 0;
 105                 int active_session_count = 0;
 106                 int waiting_session_count = 0;
 107
 108                 //get virtualservice list mutex
 109                 boost::mutex &virtualservice_list_mutex = in_vsd->get_virtualservice_list_mutex();
 110                 {
 111                         boost::mutex::scoped_lock lock(virtualservice_list_mutex);
 112
 113                         l7vsd::vslist_type  &virtualservice_list = in_vsd->get_virtualservice_list();
 114
 115                         //delete the surplus data from vs table
 116                         if (virtualservice_list.size() < static_cast<size_t>(vs_table_size)) {
 117                                 for (size_t i = vs_table_size; i > virtualservice_list.size(); i--) {
 118                                         index[0] = i;
 119                                         row = netsnmp_table_data_get_from_oid(vs_table->table, index, 1);
 120                                         if (row == NULL) continue;
 121                                         netsnmp_table_dataset_remove_and_delete_row(vs_table, row);
 122                                 }
 123                         }
 124
 125                         //set virtual service table size
 126                         vs_table_size = virtualservice_list.size();
 127
 128                         //update virtual service table
 129                         for (l7vsd::vslist_type::iterator it = virtualservice_list.begin();
 130                                         it != virtualservice_list.end(); it++) {
 131                                 index[0] = vs_index;
 132
 133                                 //get row pointer
 134                                 row = netsnmp_table_data_get_from_oid(vs_table->table, index, 1);
 135                                 if (row == NULL) {
 136                                         row = netsnmp_create_table_data_row();
 137                                         if (row == NULL) {
 138                                                 std::string msg("create virtualservice table row failed.");
 139                                                 Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 13, msg, __FILE__, __LINE__);
 140                                                 //set error code
 141                                                 err.setter(true, msg);
 142                                                 return;
 143                                         } else {
 144
 145                                                 netsnmp_table_row_add_index(row, ASN_INTEGER, (void*)index, sizeof(int));
 146                                                 netsnmp_table_dataset_add_row(vs_table, row);
 147                                                 /*-------- DEBUG LOG --------*/
 148                                                 if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 149                                                         std::stringstream    debugstr;
 150                                                         debugstr << "function : mibdata::update_vs_table : vs_table add row.";
 151                                                         boost::format("vs_index=%d") % vs_index;
 152
 153                                                         Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 65, debugstr.str(), __FILE__, __LINE__);
 154                                                 }
 155                                                 /*------ DEBUG LOG END ------*/
 156                                         }
 157                                 }
 158
 159                                 virtualservice_element &srv = (*it)->get_element();
 160
 161                                 //get virtual service IP address infomation
 162                                 if (srv.udpmode) {
 163                                         protocol = IPPROTO_UDP;
 164                                         if (srv.udp_recv_endpoint.address().is_v4()) {
 165                                                 strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
 166                                         } else {
 167                                                 strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
 168                                                 vs_ipaddress_type = 2;
 169                                         }
 170                                         vs_port = srv.udp_recv_endpoint.port();
 171                                 } else {
 172                                         protocol = IPPROTO_TCP;
 173                                         if (srv.tcp_accept_endpoint.address().is_v4()) {
 174                                                 strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
 175                                         } else {
 176                                                 strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
 177                                                 vs_ipaddress_type = 2;
 178                                         }
 179                                         vs_port = srv.tcp_accept_endpoint.port();
 180                                 }
 181
 182                                 //get sorry server IP address infomation
 183                                 if (srv.sorry_endpoint.address().is_v4()) {
 184                                         strncpy(sorry_ipaddress, srv.sorry_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
 185                                 } else {
 186                                         strncpy(sorry_ipaddress, srv.sorry_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
 187                                         sorry_ipaddress_type = 2;
 188                                 }
 189                                 sorry_port = srv.sorry_endpoint.port();
 190
 191                                 //get protocol mudule option string
 192                                 std::stringstream protocol_module_arg;
 193                                 BOOST_FOREACH(std::string str, srv.protocol_args) {
 194                                         protocol_module_arg << str << " ";
 195                                 }
 196
 197                                 //set schedule module option string
 198                                 std::string schedule_module_arg(" ");
 199
 200                                 //set ssl flag
 201                                 int ssl_flag = srv.ssl_file_name == "" ? 0 : 1;
 202
 203                                 //set realserver size
 204                                 int rs_size = srv.realserver_vector.size();
 205
 206                                 //get http statstics
 207                                 protocol_module_base   *protocol_module_ptr = (*it)->get_protocol_module();
 208                                 stats_base& base_stats = protocol_module_ptr->get_stats();
 209                                 if ( base_stats.get_mode() == stats_base::MODE_HTTP ) {
 210                                         http_stats &httpstats = static_cast<http_stats&>(base_stats);
 211                                         http_requests.low = httpstats.http_requests.get();
 212                                         http_get_requests.low = httpstats.http_get_requests.get();
 213                                         http_post_requests.low = httpstats.http_post_requests.get();
 214                                 }
 215
 216                                 //set sorry max connection
 217                                 sorry_maxconnection.low = srv.sorry_maxconnection;
 218
 219                                 //set throughput infomation
 220                                 throughput_upstream.low = srv.throughput_upstream;
 221                                 throughput_downstream.low = srv.throughput_downstream;
 222                                 qos_upstream.low = srv.qos_upstream;
 223                                 qos_downstream.low = srv.qos_downstream;
 224
 225                                 //set session infomation
 226                                 pool_session_count = (*it)->get_pool_sessions_count();
 227                                 active_session_count = (*it)->get_active_sessions_count();
 228                                 waiting_session_count = (*it)->get_waiting_sessions_count();
 229
 230                                 //set vs table row infomation
 231                                 netsnmp_set_row_column(row, COLUMN_L7VSVSINDEX, ASN_INTEGER, (char *)&vs_index, sizeof(int));
 232                                 netsnmp_set_row_column(row, COLUMN_L7VSVSPROTOCOL, ASN_INTEGER, (char *)&protocol, sizeof(int));
 233                                 netsnmp_set_row_column(row, COLUMN_L7VSVSADDRTYPE, ASN_INTEGER, (char *)&vs_ipaddress_type, sizeof(int));
 234                                 netsnmp_set_row_column(row, COLUMN_L7VSVSADDR, ASN_OCTET_STR, vs_ipaddress, strnlen(vs_ipaddress, L7VS_IPADDR_LEN));
 235                                 netsnmp_set_row_column(row, COLUMN_L7VSVSPORT, ASN_UNSIGNED, (char *)&vs_port, sizeof(int));
 236                                 netsnmp_set_row_column(row, COLUMN_L7VSVSPROTOCOLMODULENAME, ASN_OCTET_STR, (char *)srv.protocol_module_name.c_str(), srv.protocol_module_name.length());
 237                                 netsnmp_set_row_column(row, COLUMN_L7VSVSPROTOCOLMODULEOPTIONS, ASN_OCTET_STR, (char *)protocol_module_arg.str().c_str(), protocol_module_arg.str().length());
 238                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSCHEDULEMODULENAME, ASN_OCTET_STR, (char *)srv.schedule_module_name.c_str(), srv.schedule_module_name.length());
 239                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSCHEDULEMODULEOPTIONS, ASN_OCTET_STR, (char *)schedule_module_arg.c_str(), schedule_module_arg.length());
 240                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYADDRTYPE, ASN_INTEGER, (char *)&sorry_ipaddress_type,sizeof(int));
 241                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYADDR, ASN_OCTET_STR, (char *)sorry_ipaddress, strnlen(sorry_ipaddress, L7VS_IPADDR_LEN));
 242                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYPORT, ASN_INTEGER, (char *)&sorry_port, sizeof(int));
 243                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYCONNLIMIT, ASN_COUNTER64, (char *)&sorry_maxconnection, sizeof(struct counter64));
 244                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYFORCEENABLED, ASN_INTEGER, (char *)&srv.sorry_flag, sizeof(int));
 245                                 netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTUP, ASN_COUNTER64, (char *)&throughput_upstream, sizeof(struct counter64));
 246                                 netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTDOWN, ASN_COUNTER64, (char *)&throughput_downstream, sizeof(struct counter64));
 247                                 netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTUPQOS, ASN_COUNTER64, (char *)&qos_upstream, sizeof(struct counter64));
 248                                 netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTDOWNQOS, ASN_COUNTER64, (char *)&qos_downstream, sizeof(struct counter64));
 249                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSSLFLAG, ASN_INTEGER, (char *)&ssl_flag, sizeof(int));
 250                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSESSIONPOOLCOUNT, ASN_INTEGER, (char *)&pool_session_count, sizeof(int));
 251                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSESSIONACTIVECOUNT, ASN_INTEGER, (char *)&active_session_count, sizeof(int));
 252                                 netsnmp_set_row_column(row, COLUMN_L7VSVSSESSIONWAITCOUNT, ASN_INTEGER, (char *)&waiting_session_count, sizeof(int));
 253                                 netsnmp_set_row_column(row, COLUMN_L7VSVSHTTPTOTALCOUNT, ASN_COUNTER64, (char *)&http_requests, sizeof(struct counter64));
 254                                 netsnmp_set_row_column(row, COLUMN_L7VSVSHTTPGETCOUNT, ASN_COUNTER64, (char *)&http_get_requests, sizeof(struct counter64));
 255                                 netsnmp_set_row_column(row, COLUMN_L7VSVSHTTPPOSTCOUNT, ASN_COUNTER64, (char *)&http_post_requests, sizeof(struct counter64));
 256                                 netsnmp_set_row_column(row, COLUMN_L7VSVSRSNUMBER, ASN_INTEGER, (char *)&rs_size, sizeof(size_t));
 257
 258                                 //create temporary realserver data list
 259                                 int rs_index = 0;
 260                                 for (std::vector<realserver_element>::iterator rs_it = srv.realserver_vector.begin();
 261                                                 rs_it != srv.realserver_vector.end(); rs_it++) {
 262                                         rsdata data;
 263
 264                                         //set realserver infomation
 265                                         if (srv.udpmode) {
 266                                                 if ((*rs_it).udp_endpoint.address().is_v4()) {
 267                                                         strncpy(data.address, (*rs_it).udp_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
 268                                                         data.address_type = 1;
 269                                                 } else {
 270                                                         strncpy(data.address,(*rs_it).udp_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
 271                                                         data.address_type = 2;
 272                                                 }
 273                                                 data.port  = (*rs_it).udp_endpoint.port();
 274                                         } else {
 275                                                 if ((*rs_it).tcp_endpoint.address().is_v4()) {
 276                                                         strncpy(data.address, (*rs_it).tcp_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
 277                                                         data.address_type = 1;
 278                                                 } else {
 279                                                         strncpy(data.address, (*rs_it).tcp_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
 280                                                         data.address_type = 2;
 281                                                 }
 282                                                 data.port  = (*rs_it).tcp_endpoint.port();
 283                                         }
 284
 285                                         data.index = rs_index;
 286                                         data.vs_index = vs_index;
 287                                         data.forward = 1;
 288                                         data.weigth = (*rs_it).weight;
 289                                         data.active_conn = (*rs_it).get_active();
 290                                         data.inactive_conn = (*rs_it).get_inact();
 291
 292                                         //push into realserver data list
 293                                         rs_vector.push_back(data);
 294                                         rs_index++;
 295                                 }
 296                                 vs_index++;
 297                         }
 298                 }
 299
 300                 /*-------- DEBUG LOG --------*/
 301                 if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 302                         std::stringstream    debugstr;
 303                         debugstr << "function : mibdata::update_vs_table : vs_table_size=";
 304                         debugstr << vs_table_size;
 305
 306                         Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 66, debugstr.str(), __FILE__, __LINE__);
 307                 }
 308                 /*------ DEBUG LOG END ------*/
 309
 310                 //update realserver infomation with temporary realserver data list
 311                 update_rs_table(rs_vector, err);
 312         }
 313
 314         /*!
 315          * update real server table infomation.
 316          *
 317          * @param   const std::vector<rsdata> & temporary real server list
 318          * @param   error_code & error code
 319          * @retrun  void
 320          */
 321         void mibdata::update_rs_table(const std::vector<rsdata>&  rs_table_tmp, error_code&  err)
 322         {
 323                 Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 67, "mibdata::update_rs_table", __FILE__, __LINE__);
 324
 325                 oid   index[1] = {0};
 326                 int   rs_index = 0;
 327                 netsnmp_table_row *row = NULL;
 328
 329                 //delete the surplus data from real server table
 330                 if (rs_table_tmp.size() < static_cast<size_t>(rs_table_size)) {
 331                         for (size_t i = rs_table_size; i > rs_table_tmp.size(); i--) {
 332                                 index[0] = i;
 333                                 row = netsnmp_table_data_get_from_oid(rs_table->table, index, 1);
 334                                 if (row) continue;
 335                                 netsnmp_table_dataset_remove_and_delete_row(rs_table, row);
 336                         }
 337                 }
 338
 339                 rs_table_size = rs_table_tmp.size();
 340
 341                 //update real server table
 342                 for (std::vector<rsdata>::const_iterator  itr = rs_table_tmp.begin(); itr != rs_table_tmp.end(); itr++) {
 343                         index[0] = rs_index;
 344                         row = netsnmp_table_data_get_from_oid(rs_table->table, index, 1);
 345                         if (row == NULL) {
 346                                 row = netsnmp_create_table_data_row();
 347                                 if (row == NULL) {
 348                                         std::string msg("create realserver table row failed.");
 349                                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 14, msg, __FILE__, __LINE__);
 350                                         //set error code
 351                                         err.setter(true, msg);
 352                                         return ;
 353                                 } else {
 354                                         netsnmp_table_row_add_index(row, ASN_INTEGER, (void*)index, sizeof(int));
 355                                         netsnmp_table_dataset_add_row(rs_table, row);
 356                                         /*-------- DEBUG LOG --------*/
 357                                         if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 358                                                 std::stringstream    debugstr;
 359                                                 debugstr << "function : mibdata::update_rs_table : rs_table add row.";
 360                                                 boost::format("rs_index=%d") % (*itr).index;
 361
 362                                                 Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 68, debugstr.str(), __FILE__, __LINE__);
 363                                         }
 364                                         /*------ DEBUG LOG END ------*/
 365                                 }
 366                         }
 367
 368                         netsnmp_set_row_column(row, COLUMN_L7VSRSINDEX, ASN_INTEGER, (char *)&(*itr).index, sizeof(int));
 369                         netsnmp_set_row_column(row, COLUMN_L7VSRSVSINDEX, ASN_INTEGER, (char *)&(*itr).vs_index, sizeof(int));
 370                         netsnmp_set_row_column(row, COLUMN_L7VSRSADDRTYPE, ASN_INTEGER, (char *)&(*itr).address_type, sizeof(int));
 371                         netsnmp_set_row_column(row, COLUMN_L7VSRSADDR, ASN_OCTET_STR, (*itr).address, strlen((*itr).address));
 372                         netsnmp_set_row_column(row, COLUMN_L7VSRSPORT, ASN_UNSIGNED, (char *)&(*itr).port, sizeof(int));
 373                         netsnmp_set_row_column(row, COLUMN_L7VSRSFORWARD, ASN_INTEGER, (char *)&(*itr).forward, sizeof(int));
 374                         netsnmp_set_row_column(row, COLUMN_L7VSRSWEIGHT, ASN_INTEGER, (char *)&(*itr).weigth, sizeof(int));
 375                         netsnmp_set_row_column(row, COLUMN_L7VSRSACTIVECONN, ASN_INTEGER, (char *)&(*itr).active_conn, sizeof(int));
 376                         netsnmp_set_row_column(row, COLUMN_L7VSRSINACTIVECONN, ASN_INTEGER, (char *)&(*itr).inactive_conn, sizeof(int));
 377
 378                         rs_index++;
 379                 }
 380
 381                 /*-------- DEBUG LOG --------*/
 382                 if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 383                         std::stringstream    debugstr;
 384                         debugstr << "function : mibdata::update_rs_table : rs_table_size=";
 385                         debugstr << rs_table_size;
 386
 387                         Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 69, debugstr.str(), __FILE__, __LINE__);
 388                 }
 389                 /*------ DEBUG LOG END ------*/
 390         }
 391
 392         /*!
 393          * update replication state.
 394          *
 395          * @param   l7vsd * l7vsd pointer
 396          * @param   error_code & error code
 397          * @retrun  void
 398          */
 399         void mibdata::update_replication_state(l7vsd *in_vsd , error_code&  err)
 400         {
 401                 Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 70, "mibdata::update_replication_state", __FILE__, __LINE__);
 402
 403                 if (in_vsd == NULL) {
 404                         std::string msg("in_vsd pointer is NULL.");
 405                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 15, msg, __FILE__, __LINE__);
 406                         //set error code
 407                         err.setter(true, msg);
 408                         return;
 409                 }
 410
 411                 /*-------- DEBUG LOG --------*/
 412                 if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
 413                         std::stringstream    debugstr;
 414                         debugstr << "mibdata::update_replication_state arguments:";
 415                         debugstr << boost::format("in_vsd=%p") % in_vsd;
 416                         Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 71, debugstr.str(), __FILE__, __LINE__);
 417                 }
 418                 /*------ DEBUG LOG END ------*/
 419
 420                 replication::REPLICATION_MODE_TAG state = in_vsd->get_replication_state();
 421                 replication_state = static_cast<int>(state);
 422         }
 423
 424         /*!
 425          * get mibdata instance.
 426          *
 427          * @retrun  mibdata instance
 428          */
 429         mibdata& mibdata::get_instance()
 430         {
 431                 Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 72, "mibdata::get_instance", __FILE__, __LINE__);
 432                 static mibdata data;
 433                 return data;
 434         }
 435
 436         /*!
 437          * collect mibdata in l7vsd.
 438          *
 439          * @param   l7vsd * l7vsd pointer
 440          * @param   error_code & error code
 441          * @retrun  void
 442          */
 443         void mibdata::collect_mibdata(l7vsd *in_vsd, error_code&  err)
 444         {
 445                 Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 73, "mibdata::collect_mibdata", __FILE__, __LINE__);
 446
 447                 if (in_vsd == NULL) {
 448                         std::string msg("in_vsd pointer is NULL.");
 449                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 16, msg, __FILE__, __LINE__);
 450                         //set error code
 451                         err.setter(true, msg);
 452                         return;
 453                 }
 454
 455                 update_replication_state(in_vsd, err);
 456
 457                 if (err) {
 458                         std::string msg("update replication state failed.");
 459                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 17, msg, __FILE__, __LINE__);
 460                         //set error code
 461                         err.setter(true, msg);
 462                         return;
 463                 }
 464
 465                 update_vs_table(in_vsd, err);
 466
 467                 if (err) {
 468                         std::string msg("update virtual service table failed.");
 469                         Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 18, msg, __FILE__, __LINE__);
 470                         //set error code
 471                         err.setter(true, msg);
 472                         return;
 473                 }
 474         }
 475
 476         /*!
 477          * set virtual service data set.
 478          *
 479          * @param   netsnmp_table_data_set * virtual service data set
 480          * @retrun  void
 481          */
 482         void mibdata::set_vs_table(netsnmp_table_data_set*  in_vs_table)
 483         {
 484                 Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 74, "mibdata::set_vs_table", __FILE__, __LINE__);
 485                 vs_table = in_vs_table;
 486         }
 487
 488         /*!
 489          * set real server data set.
 490          *
 491          * @param   netsnmp_table_data_set * real server data set
 492          * @retrun  void
 493          */
 494         void mibdata::set_rs_table(netsnmp_table_data_set*  in_rs_table)
 495         {
 496                 Logger    logger(LOG_CAT_L7VSD_SNMPAGENT, 75, "mibdata::set_rs_table", __FILE__, __LINE__);
 497                 rs_table = in_rs_table;
 498         }
 499 }