l7vsd/unit_tests/session_thread_control_test/stub.cpp

   1 #include <boost/asio.hpp>
   2
   3 #include "l7vsd.h"
   4 #include "data_buff_base.h"
   5 #include "tcp_thread_message.h"
   6 #include "tcp_thread_message_que.h"
   7 #include "tcp_data.h"
   8 #include "tcp_socket.h"
   9 #include "tcp_session.h"
  10 #include "udp_session.h"
  11 #include "parameter.h"
  12 #include "replication.h"
  13 #include "protocol_module_control.h"
  14 #include "schedule_module_control.h"
  15 #include "stub.h"
  16
  17 // protocol_module_control　STUB code
  18 l7vs::protocol_module_control&  l7vs::protocol_module_control::getInstance(){
  19         static  protocol_module_control instance;
  20         return  instance;
  21 }
  22 void    l7vs::protocol_module_control::initialize( const std::string& infile_path ){}
  23 void    l7vs::protocol_module_control::finalize(){}
  24 l7vs::protocol_module_base*     l7vs::protocol_module_control::load_module( const std::string& modulename ){
  25         l7vs::protocol_module_base* return_value = NULL;
  26
  27 //      if( !pmcontrol_error_flag )
  28 //              return_value = new protocol_module_test1;
  29
  30         return return_value;
  31 }
  32 void    l7vs::protocol_module_control::unload_module( protocol_module_base* module_ptr ){
  33         delete  module_ptr;
  34 }
  35
  36 l7vs::schedule_module_control&  l7vs::schedule_module_control::getInstance(){
  37         static  schedule_module_control instance;
  38         return  instance;
  39 }
  40 void    l7vs::schedule_module_control::initialize( const std::string& infile_path ){}
  41 void    l7vs::schedule_module_control::finalize(){}
  42 l7vs::schedule_module_base*     l7vs::schedule_module_control::load_module( const std::string& modulename ){
  43         l7vs::schedule_module_base* return_value = NULL;
  44
  45 //      if( !smcontrol_error_flag )
  46 //              return_value = new schedule_module_test1;
  47
  48         return return_value;
  49 }
  50 void    l7vs::schedule_module_control::unload_module( schedule_module_base* module_ptr ){
  51         delete module_ptr;
  52 }
  53
  54
  55 // parameter stub
  56 l7vs::Parameter::Parameter(){}
  57
  58 l7vs::Parameter::~Parameter(){}
  59
  60 bool    l7vs::Parameter::read_file( const PARAMETER_COMPONENT_TAG in ){ return true; }
  61
  62 int             l7vs::Parameter::get_int(       const PARAMETER_COMPONENT_TAG in_tag,
  63                                                                         const std::string& in_str,
  64                                                                         error_code& err ){
  65         int     retval = 0;
  66         if( debugg_flug_struct::getInstance().param_exist_flag() ){
  67                 retval = SESSION_POOL_NUM_PARAM;
  68         }else{
  69                 err.setter( true, "not exist value." );
  70         }
  71         return retval;
  72 }
  73
  74 std::string             l7vs::Parameter::get_string(const PARAMETER_COMPONENT_TAG in_tag,
  75                                                                                         const std::string& in_str,
  76                                                                                         error_code& err){
  77         return "";
  78 }
  79
  80
  81 l7vs::Logger::Logger() :
  82         scopedLogCategory(LOG_CAT_L7VSD_LOGGER),
  83         scopedLogId(0),
  84         scopedLogMessage("Logger Constructor"),
  85         scopedLogFile(__FILE__),
  86         scopedLogLine(__LINE__) {}
  87
  88 l7vs::Logger::Logger( LOG_CATEGORY_TAG cat, const unsigned int id, const std::string& msg, const char* file, int line) :
  89         scopedLogCategory(cat),
  90         scopedLogId(id),
  91         scopedLogMessage(msg),
  92         scopedLogFile(file),
  93         scopedLogLine(line) {}
  94
  95 l7vs::Logger::~Logger(){}
  96
  97 void    l7vs::Logger::loadConf(){}
  98
  99 l7vs::LOG_LEVEL_TAG l7vs::Logger::getLogLevel( l7vs::LOG_CATEGORY_TAG ){
 100         l7vs::LOG_LEVEL_TAG             ret_tag = l7vs::LOG_LV_DEBUG;
 101         return ret_tag;
 102 }
 103
 104 bool    l7vs::Logger::setLogLevel( l7vs::LOG_CATEGORY_TAG cat, l7vs::LOG_LEVEL_TAG level ){
 105         return true;
 106 }
 107
 108 void    l7vs::Logger::putLogFatal( l7vs::LOG_CATEGORY_TAG, const unsigned int, const std::string& msg, const char*, int ){
 109         std::cout << "FATAL : " << msg << std::endl;
 110 }
 111
 112 void    l7vs::Logger::putLogError( l7vs::LOG_CATEGORY_TAG, const unsigned int, const std::string& msg, const char*, int ){
 113         std::cout << "ERROR : " << msg << std::endl;
 114 }
 115
 116 void    l7vs::Logger::putLogWarn( l7vs::LOG_CATEGORY_TAG, const unsigned int, const std::string& msg, const char*, int ){
 117         std::cout << "WARN  : " << msg << std::endl;
 118 }
 119
 120 void    l7vs::Logger::putLogInfo( l7vs::LOG_CATEGORY_TAG, const unsigned int, const std::string& msg, const char*, int ){
 121         std::cout << "INFO  : " << msg << std::endl;
 122 }
 123
 124 void    l7vs::Logger::putLogDebug( l7vs::LOG_CATEGORY_TAG, const unsigned int, const std::string& msg, const char*, int ){
 125         std::cout << "DEBUG : " << msg << std::endl;
 126 }
 127
 128 l7vs::l7vsd::l7vsd(){}
 129 l7vs::l7vsd::~l7vsd(){}
 130 l7vs::l7vsd::vslist_type::iterator      l7vs::l7vsd::search_vslist( const virtualservice_element& )     const{
 131         return vslist.begin();
 132 }
 133
 134 void    l7vs::l7vsd::release_virtual_service( const virtualservice_element& ) const {}
 135
 136
 137 int             l7vs::replication::initialize(){
 138         return 0;
 139 }
 140 void    l7vs::replication::finalize(){}
 141 void    l7vs::replication::switch_to_master(){}
 142 void    l7vs::replication::switch_to_slave(){}
 143 void*   l7vs::replication::pay_memory( const std::string& inid, unsigned int& outsize ){
 144         return NULL;
 145 }
 146 void    l7vs::replication::dump_memory(){}
 147 void    l7vs::replication::start(){}
 148 void    l7vs::replication::stop(){}
 149 void    l7vs::replication::force_replicate(){}
 150 void    l7vs::replication::reset(){}
 151 l7vs::replication::REPLICATION_MODE_TAG l7vs::replication::get_status(){
 152         l7vs::replication::REPLICATION_MODE_TAG retmode = l7vs::replication::REPLICATION_OUT;
 153         return retmode;
 154 }
 155 int             l7vs::replication::handle_send(){
 156         return 0;
 157 }
 158 void            l7vs::replication::handle_receive( const boost::system::error_code& err, size_t size ){
 159 }
 160 int             l7vs::replication::lock( const std::string& inid ){
 161         return 0;
 162 }
 163 int             l7vs::replication::unlock( const std::string& inid ){
 164         return 0;
 165 }
 166 int             l7vs::replication::refer_lock_mutex( const std::string& inid, mutex_ptr& outmutex ){
 167         return 0;
 168 }
 169
 170 /*
 171 l7vs::data_buff_base::data_buff_base(){}
 172 l7vs::data_buff_base::~data_buff_base(){}
 173 void    l7vs::data_buff_base::initialize(){}
 174 std::size_t     l7vs::data_buff_base::get_size(){
 175         return send_size;
 176 }
 177 void    l7vs::data_buff_base::set_size(const std::size_t set_size){}
 178 boost::array< char , MAX_BUFFER_SIZE>&  l7vs::data_buff_base::get_data(){
 179         return data;
 180 }
 181 void    l7vs::data_buff_base::set_data(const boost::array< char , MAX_BUFFER_SIZE>& data){}
 182 void    l7vs::data_buff_base::set_send_size(const std::size_t set_size){}
 183 std::size_t     l7vs::data_buff_base::get_send_size(){
 184         return send_size;
 185 }
 186 */
 187 l7vs::tcp_realserver_connect_socket_list::tcp_realserver_connect_socket_list(){}
 188
 189 l7vs::tcp_realserver_connect_socket_list::~tcp_realserver_connect_socket_list(){}
 190
 191 void    l7vs::tcp_realserver_connect_socket_list::push_back(list_element realserver_socket){}
 192
 193 l7vs::tcp_realserver_connect_socket_list::list_element  l7vs::tcp_realserver_connect_socket_list::get_socket(){
 194         l7vs::tcp_realserver_connect_socket_list::list_element  retval;
 195         return retval;
 196 }
 197
 198 bool    l7vs::tcp_realserver_connect_socket_list::empty(){
 199         return true;
 200 }
 201
 202 l7vs::tcp_thread_message::tcp_thread_message(){}
 203 l7vs::tcp_thread_message::~tcp_thread_message(){}
 204
 205 l7vs::tcp_thread_message_que::tcp_thread_message_que(){}
 206 l7vs::tcp_thread_message_que::~tcp_thread_message_que(){}
 207
 208 void    l7vs::tcp_thread_message_que::push(tcp_thread_message_ptr message){}
 209 l7vs::tcp_thread_message_que::tcp_thread_message_ptr    l7vs::tcp_thread_message_que::front(){
 210         return message_que.front();
 211 }
 212 bool    l7vs::tcp_thread_message_que::empty(){
 213         return true;
 214 }
 215 void    l7vs::tcp_thread_message_que::clear(){}
 216
 217 /*
 218 l7vs::tcp_data::tcp_data(){}
 219 l7vs::tcp_data::~tcp_data(){}
 220 void    l7vs::tcp_data::initialize(){}
 221 void    l7vs::tcp_data::set_endpoint(const boost::asio::ip::tcp::endpoint set_endpoint){}
 222 boost::asio::ip::tcp::endpoint  l7vs::tcp_data::get_endpoint(){
 223         return endpoint_info;
 224 }
 225 */
 226 l7vs::tcp_socket::tcp_socket(boost::asio::io_service& io) : my_socket( io ){}
 227 l7vs::tcp_socket::~tcp_socket(){}
 228 boost::asio::ip::tcp::socket&   l7vs::tcp_socket::get_socket(){
 229         return my_socket;
 230 }
 231 bool    l7vs::tcp_socket::connect(const boost::asio::ip::tcp::endpoint connect_endpoint,boost::system::error_code& ec){
 232         return true;
 233 }
 234 bool    l7vs::tcp_socket::close(boost::system::error_code& ec){
 235         return true;
 236 }
 237 bool    l7vs::tcp_socket::set_non_blocking_mode(boost::system::error_code& ec){
 238         return true;
 239 }
 240 std::size_t             l7vs::tcp_socket::write_some(boost::asio::mutable_buffers_1 buffers, boost::system::error_code& ec){
 241         size_t  ret = 0;
 242         return ret;
 243 }
 244 std::size_t             l7vs::tcp_socket::read_some(boost::asio::mutable_buffers_1 buffers, boost::system::error_code& ec){
 245         size_t  ret = 0;
 246         return ret;
 247 }
 248
 249
 250
 251
 252 l7vs::tcp_session::tcp_session(l7vs::virtualservice_tcp& vs, boost::asio::io_service& session_io) : io( session_io ),
 253                                                                                                                                                                                                         parent_service( vs ),
 254                                                                                                                                                                                                         client_socket( io ) {
 255         exit_flag = false;
 256         session_pause_flag = false;
 257         std::cout << "SESSION:CREATE" << std::endl;
 258 }
 259 l7vs::tcp_session::~tcp_session(void){
 260         std::cout << "SESSION:DESTROY" << std::endl;
 261 }
 262 l7vs::session_result_message l7vs::tcp_session::initialize(void){
 263         l7vs::session_result_message    result;
 264         return result;
 265 }
 266
 267 boost::asio::ip::tcp::socket& l7vs::tcp_session::get_client_socket(void){
 268         return client_socket.get_socket();
 269 }
 270
 271 bool    l7vs::tcp_session::is_thread_wait(void){
 272         return true;
 273 }
 274
 275 void    l7vs::tcp_session::set_virtual_service_message(const TCP_VIRTUAL_SERVICE_MESSAGE_TAG  message){
 276         switch( message ){
 277         case SORRY_STATE_ENABLE:
 278                 {
 279                         boost::mutex::scoped_lock( exit_flag_update_mutex );
 280                         exit_flag = true;
 281                 }
 282                 break;
 283         case SORRY_STATE_DISABLE:
 284                 {
 285                         boost::mutex::scoped_lock( exit_flag_update_mutex );
 286                         exit_flag = false;
 287                 }
 288                 break;
 289         case SESSION_END:
 290                 {
 291                         boost::mutex::scoped_lock( exit_flag_update_mutex );
 292                         boost::mutex::scoped_lock( module_function_sorry_disable_mutex );
 293                         exit_flag = true;
 294                         session_pause_flag = true;
 295                 }
 296                 break;
 297         case SESSION_PAUSE_ON:
 298                 {
 299                         boost::mutex::scoped_lock( module_function_sorry_disable_mutex );
 300                         session_pause_flag = true;
 301                 }
 302                 break;
 303         case SESSION_PAUSE_OFF:
 304                 {
 305                         boost::mutex::scoped_lock( module_function_sorry_disable_mutex );
 306                         session_pause_flag = false;
 307                 }
 308                 break;
 309         }
 310 }
 311
 312 void    l7vs::tcp_session::up_thread_run(void){
 313         unsigned int i = 0;
 314         std::cout << "UP:RUN" << std::endl;
 315         for( i = 0; i < (INT_MAX/12); ++i ){
 316                 {
 317                         boost::mutex::scoped_lock( exit_flag_update_mutex );
 318                         if( exit_flag )break;
 319                 }
 320         }
 321         std::cout << "UP:STOP(" << i << ")" << std::endl;
 322 }
 323
 324 void    l7vs::tcp_session::down_thread_run(void){
 325         unsigned int i = 0;
 326         std::cout << "DOWN:RUN" << std::endl;
 327         for( i = 0; i < (INT_MAX/12); ++i ){
 328                 {
 329                         boost::mutex::scoped_lock( module_function_sorry_disable_mutex );
 330                         if( session_pause_flag )break;
 331                 }
 332         }
 333         std::cout << "DOWN:STOP(" << i << ")" << std::endl;
 334 }
 335
 336 void    l7vs::tcp_session::thread_state_update(const std::bitset<TCP_SESSION_THREAD_STATE_BIT> thread_flag,const bool regist){}
 337 void    l7vs::tcp_session::up_thread_client_accept_event(const TCP_PROCESS_TYPE_TAG process_type){}
 338 void    l7vs::tcp_session::up_thread_client_receive(const TCP_PROCESS_TYPE_TAG process_type){}
 339 void    l7vs::tcp_session::up_thread_client_respond(const TCP_PROCESS_TYPE_TAG process_type){}
 340 void    l7vs::tcp_session::up_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){}
 341 void    l7vs::tcp_session::up_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 342 void    l7vs::tcp_session::up_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){}
 343 void    l7vs::tcp_session::up_thread_realserver_send(const TCP_PROCESS_TYPE_TAG process_type){}
 344 void    l7vs::tcp_session::up_thread_realserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){}
 345 void    l7vs::tcp_session::up_thread_realserver_connect(const TCP_PROCESS_TYPE_TAG process_type){}
 346 void    l7vs::tcp_session::up_thread_realserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){}
 347 void    l7vs::tcp_session::up_thread_realserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){}
 348 void    l7vs::tcp_session::up_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 349 void    l7vs::tcp_session::up_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){}
 350 void    l7vs::tcp_session::up_thread_all_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 351 void    l7vs::tcp_session::up_thread_sorryserver_send(const TCP_PROCESS_TYPE_TAG process_type){}
 352 void    l7vs::tcp_session::up_thread_sorryserver_get_destination_event(const TCP_PROCESS_TYPE_TAG process_type){}
 353 void    l7vs::tcp_session::up_thread_sorryserver_connect(const TCP_PROCESS_TYPE_TAG process_type){}
 354 void    l7vs::tcp_session::up_thread_sorryserver_connect_event(const TCP_PROCESS_TYPE_TAG process_type){}
 355 void    l7vs::tcp_session::up_thread_sorryserver_connection_fail_event(const TCP_PROCESS_TYPE_TAG process_type){}
 356 void    l7vs::tcp_session::up_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 357 void    l7vs::tcp_session::up_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){}
 358 void    l7vs::tcp_session::up_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){}
 359 void    l7vs::tcp_session::up_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){}
 360 void    l7vs::tcp_session::up_thread_sorryserver_mod_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 361 void    l7vs::tcp_session::up_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){}
 362 void    l7vs::tcp_session::up_thread_all_socket_close(void){}
 363
 364 void    l7vs::tcp_session::down_thread_realserver_receive(const TCP_PROCESS_TYPE_TAG process_type){}
 365 void    l7vs::tcp_session::down_thread_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 366 void    l7vs::tcp_session::down_thread_realserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){}
 367 void    l7vs::tcp_session::down_thread_all_realserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 368 void    l7vs::tcp_session::down_thread_client_connection_chk_event(const TCP_PROCESS_TYPE_TAG process_type){}
 369 void    l7vs::tcp_session::down_thread_client_respond_event(const TCP_PROCESS_TYPE_TAG process_type){}
 370 void    l7vs::tcp_session::down_thread_client_send(const TCP_PROCESS_TYPE_TAG process_type){}
 371 void    l7vs::tcp_session::down_thread_client_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 372 void    l7vs::tcp_session::down_thread_client_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){}
 373 void    l7vs::tcp_session::down_thread_sorryserver_receive(const TCP_PROCESS_TYPE_TAG process_type){}
 374 void    l7vs::tcp_session::down_thread_sorryserver_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 375 void    l7vs::tcp_session::down_thread_sorryserver_disconnect_event(const TCP_PROCESS_TYPE_TAG process_type){}
 376 void    l7vs::tcp_session::down_thread_sorry_enable_event(const TCP_PROCESS_TYPE_TAG process_type){}
 377 void    l7vs::tcp_session::down_thread_sorryserver_mod_disconnect(const TCP_PROCESS_TYPE_TAG process_type){}
 378 void    l7vs::tcp_session::down_thread_sorry_disable_event(const TCP_PROCESS_TYPE_TAG process_type){}
 379 void    l7vs::tcp_session::down_thread_exit(const TCP_PROCESS_TYPE_TAG process_type){}
 380 void    l7vs::tcp_session::down_thread_all_socket_close(){}
 381
 382
 383 l7vs::udp_session::udp_session(virtualservice_udp& vs, boost::asio::io_service& session_io) :   io( session_io ),
 384                                                                                                                                                                                                 parent_service( vs ),
 385                                                                                                                                                                                                 client_side_socket( io ) {}
 386 l7vs::udp_session::~udp_session(){}
 387 l7vs::session_result_message    l7vs::udp_session::initialize(const udp_endpoint listen_end){
 388         l7vs::session_result_message    result;
 389         return result;
 390 }
 391
 392 void    l7vs::udp_session::set_virtual_service_message(const UDP_VIRTUAL_SERVICE_MESSAGE_TAG message){}
 393 void    l7vs::udp_session::run(void){}
 394 bool    l7vs::udp_session::client_send(const udp_endpoint client_endpoint, const udp_session_buff& data_buff,const std::size_t data_size,boost::system::error_code& ec){
 395         return true;
 396 }
 397 void    l7vs::udp_session::release_request(const boost::thread::id release_thread_id){}
 398
 399 void    l7vs::udp_session::make_request_thread(const int max_count){}
 400 void    l7vs::udp_session::active_request_thread(const udp_endpoint client_endpoint , const udp_session_buff receive_data, const std::size_t receive_size){}
 401 void    l7vs::udp_session::all_active_request_stop(void){}
 402