l7vsd/unit_tests/virtualservice_test/vs_tcp_thread_test.cpp

   1
   2 #include <iostream>
   3 #include <sstream>
   4 #include <boost/test/included/unit_test.hpp>
   5 #include <boost/archive/text_oarchive.hpp>
   6 #include <boost/archive/text_iarchive.hpp>
   7 #include <boost/thread.hpp>
   8
   9 #include "stub.h"
  10 #include "virtualservice.h"
  11 #include "vs_tcp.h"
  12
  13 #include "protocol_module_test1.h"
  14 #include "schedule_module_test1.h"
  15
  16 using namespace boost::unit_test;
  17
  18 typedef boost::asio::ip::tcp::endpoint  tcp_ep_type;
  19 typedef boost::asio::ip::udp::endpoint  udp_ep_type;
  20
  21 int     counter;
  22
  23 //Acceptテスト用Client
  24 void    client(){
  25         boost::system::error_code       b_err;
  26
  27         boost::asio::io_service dispatcher;
  28         boost::asio::ip::tcp::socket    sock( dispatcher );
  29         sock.connect( tcp_ep_type( boost::asio::ip::address_v4::loopback(), (60000) ), b_err );
  30         std::cout << "connect" << std::endl;
  31
  32         usleep( 10000 );
  33
  34         sock.close( b_err );
  35 }
  36
  37 class   vs_access{
  38 protected:
  39         boost::asio::io_service         dispatcher;
  40
  41         l7vs::vs_tcp*                           vs;
  42         l7vs::l7vsd                                     vsd;
  43         l7vs::replication*                      rep;
  44         l7vs::error_code                        vs_err;
  45
  46         boost::condition                        cond;
  47 public:
  48         vs_access() : vs( NULL ), rep( NULL ) {}
  49         ~vs_access(){}
  50
  51         void    initialize( l7vs::virtualservice_element& in_elem ){
  52                 rep     = new l7vs::replication();
  53                 vs      = new l7vs::vs_tcp( vsd, *rep, in_elem );
  54         }
  55
  56         void    finalize(){
  57                 vs->finalize( vs_err );
  58                 usleep(10);
  59                 if( NULL != vs ){
  60                         delete vs;
  61                         vs = NULL;
  62                 }
  63                 if( NULL != rep ){
  64                         delete rep;
  65                         rep = NULL;
  66                 }
  67         }
  68
  69         void    start(){
  70                 cond.notify_all();
  71         }
  72
  73         void    step(){
  74                 cond.notify_one();
  75         }
  76
  77         l7vs::vs_tcp*   get_vs(){
  78                 return vs;
  79         }
  80
  81         void    client(){
  82                 boost::system::error_code       b_err;
  83
  84                 boost::asio::io_service client_io;
  85                 boost::asio::ip::tcp::socket    sock( client_io );
  86                 boost::mutex    mtx;
  87                 boost::mutex::scoped_lock       lk( mtx );
  88                 cond.wait( lk );
  89
  90                 sock.connect( tcp_ep_type( boost::asio::ip::address_v4::loopback(), (60000) ), b_err );
  91                 std::cout << "connect" << std::endl;
  92
  93                 usleep( 10000 );
  94
  95                 sock.close( b_err );
  96         }
  97
  98         void    rs_list_lock(){
  99                 boost::mutex    mtx;
 100                 boost::mutex::scoped_lock       lk( mtx );
 101                 cond.wait( lk );
 102
 103                 vs->rs_list_lock();
 104 //              std::cout << "" << std::endl;
 105         }
 106         void            rs_list_unlock(){
 107                 boost::mutex    mtx;
 108                 boost::mutex::scoped_lock       lk( mtx );
 109                 cond.wait( lk );
 110
 111                 vs->rs_list_unlock();
 112
 113         }
 114
 115         void            get_element( l7vs::virtualservice_element* elem ){
 116                 boost::mutex    mtx;
 117                 boost::mutex::scoped_lock       lk( mtx );
 118                 cond.wait( lk );
 119
 120                 *(elem) = vs->get_element();
 121
 122         }
 123
 124         void            get_qos_upstream( unsigned long long* val ){
 125                 boost::mutex    mtx;
 126                 boost::mutex::scoped_lock       lk( mtx );
 127                 cond.wait( lk );
 128
 129                 *val = vs->get_qos_upstream();
 130
 131         }
 132         void            get_qos_downstream( unsigned long long* val ){
 133                 boost::mutex    mtx;
 134                 boost::mutex::scoped_lock       lk( mtx );
 135                 cond.wait( lk );
 136
 137                 *val = vs->get_qos_downstream();
 138
 139         }
 140         void            get_throughput_upstream( unsigned long long* val ){
 141                 boost::mutex    mtx;
 142                 boost::mutex::scoped_lock       lk( mtx );
 143                 cond.wait( lk );
 144
 145                 *val = vs->get_throughput_upstream();
 146
 147         }
 148         void            get_throughput_downstream( unsigned long long* val ){
 149                 boost::mutex    mtx;
 150                 boost::mutex::scoped_lock       lk( mtx );
 151                 cond.wait( lk );
 152
 153                 *val = vs->get_throughput_downstream();
 154
 155         }
 156         void            get_up_recv_size( unsigned long long* val ){
 157                 boost::mutex    mtx;
 158                 boost::mutex::scoped_lock       lk( mtx );
 159                 cond.wait( lk );
 160
 161                 *val = vs->get_up_recv_size();
 162
 163         }
 164         void            get_up_send_size( unsigned long long* val ){
 165                 boost::mutex    mtx;
 166                 boost::mutex::scoped_lock       lk( mtx );
 167                 cond.wait( lk );
 168
 169                 *val = vs->get_up_send_size();
 170
 171         }
 172         void            get_down_recv_size( unsigned long long* val ){
 173                 boost::mutex    mtx;
 174                 boost::mutex::scoped_lock       lk( mtx );
 175                 cond.wait( lk );
 176
 177                 *val = vs->get_down_recv_size();
 178
 179         }
 180         void            get_down_send_size( unsigned long long* val ){
 181                 boost::mutex    mtx;
 182                 boost::mutex::scoped_lock       lk( mtx );
 183                 cond.wait( lk );
 184
 185                 *val = vs->get_down_send_size();
 186
 187         }
 188
 189         void            update_up_recv_size( unsigned long long size ){
 190                 boost::mutex    mtx;
 191                 boost::mutex::scoped_lock       lk( mtx );
 192                 cond.wait( lk );
 193
 194                 vs->update_up_recv_size( size );
 195
 196         }
 197         void            update_up_send_size( unsigned long long size ){
 198                 boost::mutex    mtx;
 199                 boost::mutex::scoped_lock       lk( mtx );
 200                 cond.wait( lk );
 201
 202                 vs->update_up_send_size( size );
 203
 204         }
 205         void            update_down_recv_size( unsigned long long size ){
 206                 boost::mutex    mtx;
 207                 boost::mutex::scoped_lock       lk( mtx );
 208                 cond.wait( lk );
 209
 210                 vs->update_down_recv_size( size );
 211
 212         }
 213         void            update_down_send_size( unsigned long long size ){
 214                 boost::mutex    mtx;
 215                 boost::mutex::scoped_lock       lk( mtx );
 216                 cond.wait( lk );
 217
 218                 vs->update_down_send_size( size );
 219
 220         }
 221
 222         void            get_protocol_module( l7vs::protocol_module_base* in_pm ){
 223                 boost::mutex    mtx;
 224                 boost::mutex::scoped_lock       lk( mtx );
 225                 cond.wait( lk );
 226
 227                 in_pm = vs->get_protocol_module();
 228
 229         }
 230         void            get_schedule_module( l7vs::schedule_module_base* in_sm ){
 231                 boost::mutex    mtx;
 232                 boost::mutex::scoped_lock       lk( mtx );
 233                 cond.wait( lk );
 234
 235                 in_sm = vs->get_schedule_module();
 236
 237         }
 238
 239         void            vs_initialize(){
 240                 l7vs::error_code        vs_err;
 241                 boost::mutex    mtx;
 242                 boost::mutex::scoped_lock       lk( mtx );
 243                 cond.wait( lk );
 244
 245                 vs->initialize( vs_err );
 246
 247         }
 248         void            vs_finalize(){
 249                 l7vs::error_code        vs_err;
 250                 boost::mutex    mtx;
 251                 boost::mutex::scoped_lock       lk( mtx );
 252                 cond.wait( lk );
 253
 254                 vs->finalize( vs_err );
 255
 256                 BOOST_MESSAGE( "finalize." << boost::this_thread::get_id() );
 257         }
 258
 259         void            vs_eq( const l7vs::virtualservice_base* in_vs, bool* ret ){
 260                 boost::mutex    mtx;
 261                 boost::mutex::scoped_lock       lk( mtx );
 262                 cond.wait( lk );
 263
 264                 *ret = vs->operator==(*in_vs);
 265
 266         }
 267         void            vs_ne( const l7vs::virtualservice_base* in_vs, bool* ret ){
 268                 boost::mutex    mtx;
 269                 boost::mutex::scoped_lock       lk( mtx );
 270                 cond.wait( lk );
 271
 272                 *ret = vs->operator!=(*in_vs);
 273
 274         }
 275
 276         void            set_virtualservice( const l7vs::virtualservice_element& elem ){
 277                 l7vs::error_code        vs_err;
 278                 boost::mutex    mtx;
 279                 boost::mutex::scoped_lock       lk( mtx );
 280                 cond.wait( lk );
 281
 282                 vs->set_virtualservice( elem, vs_err );
 283
 284         }
 285         void            edit_virtualservice( const l7vs::virtualservice_element& elem ){
 286                 l7vs::error_code        vs_err;
 287                 boost::mutex    mtx;
 288                 boost::mutex::scoped_lock       lk( mtx );
 289                 cond.wait( lk );
 290
 291                 vs->edit_virtualservice( elem, vs_err );
 292
 293         }
 294
 295         void            add_realserver( const l7vs::virtualservice_element& elem ){
 296                 l7vs::error_code        vs_err;
 297                 boost::mutex    mtx;
 298                 boost::mutex::scoped_lock       lk( mtx );
 299                 cond.wait( lk );
 300
 301                 vs->add_realserver( elem, vs_err );
 302
 303         }
 304         void            edit_realserver( const l7vs::virtualservice_element& elem ){
 305                 l7vs::error_code        vs_err;
 306                 boost::mutex    mtx;
 307                 boost::mutex::scoped_lock       lk( mtx );
 308                 cond.wait( lk );
 309
 310                 vs->edit_realserver( elem, vs_err );
 311
 312         }
 313         void            del_realserver( const l7vs::virtualservice_element& elem ){
 314                 l7vs::error_code        vs_err;
 315                 boost::mutex    mtx;
 316                 boost::mutex::scoped_lock       lk( mtx );
 317                 cond.wait( lk );
 318
 319                 vs->del_realserver( elem, vs_err );
 320
 321         }
 322
 323         void            run(){
 324                 vs->run();
 325         }
 326         void            stop(){
 327                 boost::mutex    mtx;
 328                 boost::mutex::scoped_lock       lk( mtx );
 329                 cond.wait( lk );
 330
 331                 vs->stop();
 332
 333         }
 334
 335         void            connection_active( const tcp_ep_type& ep ){
 336                 boost::mutex    mtx;
 337                 boost::mutex::scoped_lock       lk( mtx );
 338                 cond.wait( lk );
 339
 340                 vs->connection_active( ep );
 341
 342         }
 343         void            connection_inactive( const tcp_ep_type& ep ){
 344                 boost::mutex    mtx;
 345                 boost::mutex::scoped_lock       lk( mtx );
 346                 cond.wait( lk );
 347
 348                 vs->connection_inactive( ep );
 349
 350         }
 351         void            release_session( const l7vs::tcp_session* session_ptr ){
 352                 boost::mutex    mtx;
 353                 boost::mutex::scoped_lock       lk( mtx );
 354                 cond.wait( lk );
 355
 356                 vs->release_session( session_ptr );
 357         }
 358 };
 359
 360 //test case1  create,initialize,run,stop,finalize,destroy(normal case)
 361 void    virtualservice_tcp_test1(){
 362         counter = 1;
 363
 364         //replicationエリアを作成しておく
 365         debugg_flug_struct::getInstance().create_rep_area();
 366
 367         boost::asio::io_service         dispatcher;
 368
 369         l7vs::l7vsd                                     vsd;
 370         l7vs::replication                       rep;
 371
 372         debugg_flug_struct::getInstance().pmcontrol_err_flag()  = false;
 373         debugg_flug_struct::getInstance().smcontrol_err_flag()  = false;
 374         debugg_flug_struct::getInstance().param_exist_flag() = false;
 375
 376         l7vs::error_code                        vs_err;
 377         boost::system::error_code       test_err;
 378
 379         std::stringstream       tmp_tcp_ep;
 380         std::stringstream       tmp_udp_ep;
 381         std::stringstream       tmp_sorry_ep;
 382
 383         l7vs::virtualservice_element    elem1;
 384
 385         //set element value
 386         elem1.udpmode                                   = false;
 387         elem1.tcp_accept_endpoint               =
 388                         tcp_ep_type( boost::asio::ip::address_v4::loopback(), (60000) );
 389         elem1.udp_recv_endpoint                 = udp_ep_type( boost::asio::ip::address::from_string( "10.144.169.87" ), (50000) );
 390         elem1.realserver_vector.clear();
 391         elem1.protocol_module_name              = "PMtest1";
 392         elem1.schedule_module_name              = "SMtest1";
 393         elem1.protocol_args.clear();
 394         elem1.sorry_maxconnection               = 1234LL;
 395         elem1.sorry_endpoint                    = tcp_ep_type();
 396         elem1.sorry_flag                                = false;
 397         elem1.qos_upstream                              = 65535ULL;
 398         elem1.qos_downstream                    = 32767ULL;
 399
 400         //vs作成
 401         vs_access       vst;
 402
 403         vst.initialize( elem1 );
 404         vst.get_vs()->initialize( vs_err );
 405
 406         //同一メソッドの多重アクセス
 407
 408
 409         // unit_test[1]  operator==に２スレッドから同時アクセス
 410         std::cout << counter++ << std::endl;
 411         //比較用のVSを2個作成
 412         l7vs::virtualservice_element    elem2;
 413         elem2.udpmode                                   = false;
 414         elem2.tcp_accept_endpoint               =
 415                         tcp_ep_type( boost::asio::ip::address::from_string( "10.144.169.30" ), (40000) );
 416         elem2.udp_recv_endpoint                 = udp_ep_type( boost::asio::ip::address::from_string( "10.144.169.20" ), (50000) );
 417         elem2.realserver_vector.clear();
 418         elem2.protocol_module_name              = "PMtest1";
 419         elem2.schedule_module_name              = "SMtest1";
 420         elem2.protocol_args.clear();
 421         elem2.sorry_maxconnection               = 1234LL;
 422         elem2.sorry_endpoint                    = tcp_ep_type();
 423         elem2.sorry_flag                                = false;
 424         elem2.qos_upstream                              = 65535ULL;
 425         elem2.qos_downstream                    = 32767ULL;
 426
 427         l7vs::vs_tcp*   vs1 = new l7vs::vs_tcp( vsd, rep, elem1 );
 428         l7vs::vs_tcp*   vs2 = new l7vs::vs_tcp( vsd, rep, elem2 );
 429         bool    retbool1 = true;
 430         bool    retbool2 = true;
 431
 432         BOOST_CHECK( vst.get_vs()->get_element().udpmode == elem1.udpmode );
 433         BOOST_CHECK( vst.get_vs()->get_element().tcp_accept_endpoint == elem1.tcp_accept_endpoint );
 434         BOOST_CHECK( vst.get_vs()->get_element().udp_recv_endpoint == elem1.udp_recv_endpoint );
 435         BOOST_CHECK( vst.get_vs()->get_element().protocol_module_name == elem1.protocol_module_name );
 436
 437         {
 438                 boost::thread   eq1( &vs_access::vs_eq, &vst, vs1, &retbool1 );
 439                 boost::thread   eq2( &vs_access::vs_eq, &vst, vs2, &retbool2 );
 440
 441                 usleep( 1000 );
 442                 vst.start();
 443                 usleep( 1000 );
 444                 eq1.join();
 445                 eq2.join();
 446         }
 447
 448         BOOST_CHECK( retbool1 );
 449         BOOST_CHECK( !retbool2 );
 450
 451         // unit_test[2]  operator!=に２スレッドから同時アクセス
 452         std::cout << counter++ << std::endl;
 453         {
 454                 boost::thread   ne1( &vs_access::vs_ne, &vst, vs1, &retbool1 );
 455                 boost::thread   ne2( &vs_access::vs_ne, &vst, vs2, &retbool2 );
 456
 457                 usleep( 1000 );
 458                 vst.start();
 459                 usleep( 1000 );
 460                 ne1.join();
 461                 ne2.join();
 462         }
 463
 464         BOOST_CHECK( !retbool1 );
 465         BOOST_CHECK( retbool2 );
 466
 467         // unit_test[3]  rs_list_lockに２スレッドから同時アクセス
 468         std::cout << counter++ << std::endl;
 469         {
 470                 boost::thread   lk1( &vs_access::rs_list_lock, &vst );
 471                 boost::thread   lk2( &vs_access::rs_list_lock, &vst );
 472
 473                 usleep( 1000 );
 474                 vst.start();
 475                 usleep( 1000 );
 476                 lk1.join();
 477                 lk2.join();
 478         }
 479         BOOST_CHECK( vst.get_vs()->get_ref_count() == 2ULL );
 480
 481         // unit_test[4]  rs_list_unlockに２スレッドから同時アクセス
 482         std::cout << counter++ << std::endl;
 483         {
 484                 boost::thread   ulk1( &vs_access::rs_list_unlock, &vst );
 485                 boost::thread   ulk2( &vs_access::rs_list_unlock, &vst );
 486
 487                 usleep( 1000 );
 488                 vst.start();
 489                 usleep( 1000 );
 490                 ulk1.join();
 491                 ulk2.join();
 492         }
 493         BOOST_CHECK( vst.get_vs()->get_ref_count() == 0ULL );
 494
 495         // unit_test[5]  get_elementに２スレッドから同時アクセス
 496         l7vs::virtualservice_element    test_elem1;
 497         l7vs::virtualservice_element    test_elem2;
 498         std::cout << counter++ << std::endl;
 499         {
 500                 boost::thread   get_elem1( &vs_access::get_element, &vst, &test_elem1 );
 501                 boost::thread   get_elem2( &vs_access::get_element, &vst, &test_elem2 );
 502
 503                 usleep( 1000 );
 504                 vst.start();
 505                 usleep( 1000 );
 506                 get_elem1.join();
 507                 get_elem2.join();
 508         }
 509         BOOST_CHECK( test_elem1 == test_elem2 );
 510
 511         // unit_test[6]  connection_activeに２スレッドから同時アクセス
 512         std::cout << counter++ << std::endl;
 513         //RSを２つ追加しておく
 514         l7vs::virtualservice_element    elem3;
 515         //set element value
 516         elem3.udpmode                                   = false;
 517         elem3.tcp_accept_endpoint               =
 518                         tcp_ep_type( boost::asio::ip::address_v4::loopback(), (60000) );
 519         elem3.udp_recv_endpoint                 = udp_ep_type( boost::asio::ip::address::from_string( "10.144.169.20" ), (50000) );
 520         elem3.realserver_vector.clear();
 521         elem3.protocol_module_name              = "PMtest1";
 522         elem3.schedule_module_name              = "SMtest1";
 523         elem3.protocol_args.clear();
 524         elem3.sorry_maxconnection               = 1234LL;
 525         elem3.sorry_endpoint                    = tcp_ep_type();
 526         elem3.sorry_flag                                = false;
 527         elem3.qos_upstream                              = 65535ULL;
 528         elem3.qos_downstream                    = 32767ULL;
 529         for( size_t i = 0; i < 2; ++i ){
 530                 l7vs::realserver_element        rs_elem;
 531                 rs_elem.tcp_endpoint = tcp_ep_type( boost::asio::ip::address::from_string( "192.168.10.10" ), (i+8080) );
 532                 elem3.realserver_vector.push_back( rs_elem );
 533         }
 534         vst.get_vs()->add_realserver( elem3, vs_err );
 535         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 2 );
 536         tcp_ep_type             ep1 = elem3.realserver_vector[0].tcp_endpoint;
 537         tcp_ep_type             ep2 = elem3.realserver_vector[1].tcp_endpoint;
 538         {
 539                 boost::thread   con_act1( &vs_access::connection_active, &vst, ep1 );
 540                 boost::thread   con_act2( &vs_access::connection_active, &vst, ep2 );
 541
 542                 usleep( 100000 );
 543                 vst.start();
 544                 usleep( 1000 );
 545                 con_act1.join();
 546                 con_act2.join();
 547         }
 548         BOOST_CHECK( vst.get_vs()->get_element().realserver_vector[0].get_active() == 1 );
 549         BOOST_CHECK( vst.get_vs()->get_element().realserver_vector[1].get_active() == 1 );
 550
 551         // unit_test[7]  connection_inactiveに２スレッドから同時アクセス
 552         std::cout << counter++ << std::endl;
 553         {
 554                 boost::thread   con_inact1( &vs_access::connection_inactive, &vst, ep2 );
 555                 boost::thread   con_inact2( &vs_access::connection_inactive, &vst, ep1 );
 556
 557                 usleep( 100000 );
 558                 vst.start();
 559                 usleep( 1000 );
 560                 con_inact1.join();
 561                 con_inact2.join();
 562         }
 563         BOOST_CHECK( vst.get_vs()->get_element().realserver_vector[0].get_active() == 0 );
 564         BOOST_CHECK( vst.get_vs()->get_element().realserver_vector[1].get_active() == 0 );
 565         BOOST_CHECK( vst.get_vs()->get_element().realserver_vector[0].get_inact() == 1 );
 566         BOOST_CHECK( vst.get_vs()->get_element().realserver_vector[1].get_inact() == 1 );
 567
 568
 569 //      vst.get_vs()->initialize( vs_err );
 570         boost::thread   vs_run( &vs_access::run, &vst );
 571         usleep( 1000 );
 572         BOOST_MESSAGE( vst.get_vs()->get_pool_sessions().size() );
 573         BOOST_CHECK( vst.get_vs()->get_pool_sessions().size() == (l7vs::virtualservice_base::SESSION_POOL_NUM_DEFAULT - 1) );
 574
 575         // unit_test[8]  release_sessionに２スレッドから同時アクセス
 576         // unit_test[9]  stopに２スレッドから同時アクセス
 577         //あらかじめclientからconnectして、ActiveSessionを２つ以上にしておく
 578         std::cout << counter++ << std::endl;
 579         std::cout << counter++ << std::endl;
 580         {
 581                 usleep( 1000 );
 582                 boost::thread   cl1( &client );
 583                 boost::thread   cl2( &client );
 584                 usleep( 1000000 );
 585
 586                 BOOST_CHECK( vst.get_vs()->get_pool_sessions().size() == l7vs::virtualservice_base::SESSION_POOL_NUM_DEFAULT-3 );
 587                 BOOST_CHECK( vst.get_vs()->get_waiting_sessions().size() == 1 );
 588                 BOOST_CHECK( vst.get_vs()->get_active_sessions().size() == 2 );
 589
 590                 cl1.join();
 591                 cl2.join();
 592
 593                 //stopのスレッドを作成
 594                 boost::thread   stop1( &vs_access::stop, &vst );
 595                 boost::thread   stop2( &vs_access::stop, &vst );
 596
 597                 usleep( 100000 );
 598                 vst.start();
 599                 usleep( 100000 );
 600                 //stopの流れでrelease_sessionも呼ばれる
 601                 stop1.join();
 602                 stop2.join();
 603         }
 604         std::cout << vst.get_vs()->get_pool_sessions().size() << std::endl;
 605         BOOST_CHECK( vst.get_vs()->get_pool_sessions().size() == l7vs::virtualservice_base::SESSION_POOL_NUM_DEFAULT-1 );
 606         std::cout << vst.get_vs()->get_waiting_sessions().size() << std::endl;
 607         BOOST_CHECK( vst.get_vs()->get_waiting_sessions().size() == 1 );
 608         vs_run.join();
 609
 610         // unit_test[10]  get_qos_upstreamに２スレッドから同時アクセス
 611         std::cout << counter++ << std::endl;
 612         unsigned long long      qos1 = 0;
 613         unsigned long long      qos2 = 0;
 614         {
 615                 boost::thread   qosup1( &vs_access::get_qos_upstream, &vst, &qos1 );
 616                 boost::thread   qosup2( &vs_access::get_qos_upstream, &vst, &qos2 );
 617
 618                 usleep( 100000 );
 619                 vst.start();
 620                 usleep( 1000 );
 621                 qosup1.join();
 622                 qosup2.join();
 623         }
 624         BOOST_CHECK( qos1 == elem1.qos_upstream );
 625         BOOST_CHECK( qos2 == elem1.qos_upstream );
 626
 627         // unit_test[11]  get_qos_downstreamに２スレッドから同時アクセス
 628         std::cout << counter++ << std::endl;
 629         {
 630                 boost::thread   qosdown1( &vs_access::get_qos_downstream, &vst, &qos1 );
 631                 boost::thread   qosdown2( &vs_access::get_qos_downstream, &vst, &qos2 );
 632
 633                 usleep( 100000 );
 634                 vst.start();
 635                 usleep( 1000 );
 636                 qosdown1.join();
 637                 qosdown2.join();
 638         }
 639         BOOST_CHECK( qos1 == elem1.qos_downstream );
 640         BOOST_CHECK( qos2 == elem1.qos_downstream );
 641
 642         // unit_test[12]  get_throughput_upstreamに２スレッドから同時アクセス
 643         std::cout << counter++ << std::endl;
 644         unsigned long long      throughput1 = 65535ULL;
 645         unsigned long long      throughput2 = 65535ULL;
 646         {
 647                 boost::thread   get_throughput1( &vs_access::get_throughput_upstream, &vst, &throughput1 );
 648                 boost::thread   get_throughput2( &vs_access::get_throughput_upstream, &vst, &throughput2 );
 649
 650                 usleep( 100000 );
 651                 vst.start();
 652                 usleep( 1000 );
 653                 get_throughput1.join();
 654                 get_throughput2.join();
 655         }
 656         BOOST_CHECK( throughput1 == 0ULL );
 657         BOOST_CHECK( throughput1 == 0ULL );
 658
 659         // unit_test[13]  get_throughput_downstreamに２スレッドから同時アクセス
 660         std::cout << counter++ << std::endl;
 661         throughput1 = 65535ULL;
 662         throughput2 = 65535ULL;
 663         {
 664                 boost::thread   thread1( &vs_access::get_throughput_downstream, &vst, &throughput1 );
 665                 boost::thread   thread2( &vs_access::get_throughput_downstream, &vst, &throughput2 );
 666
 667                 usleep( 100000 );
 668                 vst.start();
 669                 usleep( 1000 );
 670                 thread1.join();
 671                 thread2.join();
 672         }
 673         BOOST_CHECK( throughput1 == 0ULL );
 674         BOOST_CHECK( throughput1 == 0ULL );
 675
 676         // unit_test[14]  get_up_recv_sizeに２スレッドから同時アクセス
 677         std::cout << counter++ << std::endl;
 678         unsigned long long      recv_size1      = 65535ULL;
 679         unsigned long long      recv_size2      = 65535ULL;
 680         {
 681                 boost::thread   thread1( &vs_access::get_up_recv_size, &vst, &recv_size1 );
 682                 boost::thread   thread2( &vs_access::get_up_recv_size, &vst, &recv_size2 );
 683
 684                 usleep( 100000 );
 685                 vst.start();
 686                 usleep( 1000 );
 687                 thread1.join();
 688                 thread2.join();
 689         }
 690         BOOST_CHECK( recv_size1 == 0ULL );
 691         BOOST_CHECK( recv_size2 == 0ULL );
 692
 693         // unit_test[15]  get_up_send_sizeに２スレッドから同時アクセス
 694         std::cout << counter++ << std::endl;
 695         recv_size1      = 65535ULL;
 696         recv_size2      = 65535ULL;
 697         {
 698                 boost::thread   thread1( &vs_access::get_up_send_size, &vst, &recv_size1 );
 699                 boost::thread   thread2( &vs_access::get_up_send_size, &vst, &recv_size2 );
 700
 701                 usleep( 100000 );
 702                 vst.start();
 703                 usleep( 1000 );
 704                 thread1.join();
 705                 thread2.join();
 706         }
 707         BOOST_CHECK( recv_size1 == 0ULL );
 708         BOOST_CHECK( recv_size2 == 0ULL );
 709
 710         // unit_test[16]  get_down_recv_sizeに２スレッドから同時アクセス
 711         std::cout << counter++ << std::endl;
 712         recv_size1      = 65535ULL;
 713         recv_size2      = 65535ULL;
 714         {
 715                 boost::thread   thread1( &vs_access::get_down_recv_size, &vst, &recv_size1 );
 716                 boost::thread   thread2( &vs_access::get_down_recv_size, &vst, &recv_size2 );
 717
 718                 usleep( 100000 );
 719                 vst.start();
 720                 usleep( 1000 );
 721                 thread1.join();
 722                 thread2.join();
 723         }
 724         BOOST_CHECK( recv_size1 == 0ULL );
 725         BOOST_CHECK( recv_size2 == 0ULL );
 726
 727         // unit_test[17]  get_down_send_sizeに２スレッドから同時アクセス
 728         std::cout << counter++ << std::endl;
 729         recv_size1      = 65535ULL;
 730         recv_size2      = 65535ULL;
 731         {
 732                 boost::thread   thread1( &vs_access::get_down_send_size, &vst, &recv_size1 );
 733                 boost::thread   thread2( &vs_access::get_down_send_size, &vst, &recv_size2 );
 734
 735                 usleep( 100000 );
 736                 vst.start();
 737                 usleep( 1000 );
 738                 thread1.join();
 739                 thread2.join();
 740         }
 741         BOOST_CHECK( recv_size1 == 0ULL );
 742         BOOST_CHECK( recv_size2 == 0ULL );
 743
 744         // unit_test[18]  update_up_recv_sizeに２スレッドから同時アクセス
 745         std::cout << counter++ << std::endl;
 746         {
 747                 boost::thread   thread1( &vs_access::update_up_recv_size, &vst, 1000ULL );
 748                 boost::thread   thread2( &vs_access::update_up_recv_size, &vst, 200ULL );
 749
 750                 usleep( 100000 );
 751                 vst.start();
 752                 usleep( 1000 );
 753                 thread1.join();
 754                 thread2.join();
 755         }
 756         recv_size1 = vst.get_vs()->get_up_recv_size();
 757         BOOST_CHECK( recv_size1 == 1200ULL );
 758
 759         // unit_test[19]  update_up_send_sizeに２スレッドから同時アクセス
 760         std::cout << counter++ << std::endl;
 761         {
 762                 boost::thread   thread1( &vs_access::update_up_send_size, &vst, 100ULL );
 763                 boost::thread   thread2( &vs_access::update_up_send_size, &vst, 300ULL );
 764
 765                 usleep( 100000 );
 766                 vst.start();
 767                 usleep( 1000 );
 768                 thread1.join();
 769                 thread2.join();
 770         }
 771         recv_size1 = vst.get_vs()->get_up_send_size();
 772         BOOST_CHECK( recv_size1 == 400ULL );
 773
 774         // unit_test[20]  update_down_recv_sizeに２スレッドから同時アクセス
 775         std::cout << counter++ << std::endl;
 776         {
 777                 boost::thread   thread1( &vs_access::update_down_recv_size, &vst, 10ULL );
 778                 boost::thread   thread2( &vs_access::update_down_recv_size, &vst, 500ULL );
 779
 780                 usleep( 100000 );
 781                 vst.start();
 782                 usleep( 1000 );
 783                 thread1.join();
 784                 thread2.join();
 785         }
 786         recv_size1 = vst.get_vs()->get_down_recv_size();
 787         BOOST_CHECK( recv_size1 == 510ULL );
 788
 789         // unit_test[21]  update_down_send_sizeに２スレッドから同時アクセス
 790         std::cout << counter++ << std::endl;
 791         {
 792                 boost::thread   thread1( &vs_access::update_down_send_size, &vst, 8000ULL );
 793                 boost::thread   thread2( &vs_access::update_down_send_size, &vst, 5000ULL );
 794
 795                 usleep( 100000 );
 796                 vst.start();
 797                 usleep( 1000 );
 798                 thread1.join();
 799                 thread2.join();
 800         }
 801         recv_size1 = vst.get_vs()->get_down_send_size();
 802         BOOST_CHECK( recv_size1 == 13000ULL );
 803
 804         // unit_test[22]  get_protocol_moduleに２スレッドから同時アクセス
 805         std::cout << counter++ << std::endl;
 806         l7vs::protocol_module_base*     pmb1 = NULL;
 807         l7vs::protocol_module_base*     pmb2 = NULL;
 808         {
 809                 boost::thread   thread1( &vs_access::get_protocol_module, &vst, pmb1 );
 810                 boost::thread   thread2( &vs_access::get_protocol_module, &vst, pmb2 );
 811
 812                 usleep( 100000 );
 813                 vst.start();
 814                 usleep( 1000 );
 815                 thread1.join();
 816                 thread2.join();
 817         }
 818         BOOST_CHECK( pmb1 == pmb2 );
 819
 820         // unit_test[23]  get_schedule_moduleに２スレッドから同時アクセス
 821         std::cout << counter++ << std::endl;
 822         l7vs::schedule_module_base*     smb1 = NULL;
 823         l7vs::schedule_module_base*     smb2 = NULL;
 824         {
 825                 boost::thread   thread1( &vs_access::get_schedule_module, &vst, smb1 );
 826                 boost::thread   thread2( &vs_access::get_schedule_module, &vst, smb2 );
 827
 828                 usleep( 100000 );
 829                 vst.start();
 830                 usleep( 1000 );
 831                 thread1.join();
 832                 thread2.join();
 833         }
 834         BOOST_CHECK( smb1 == smb2 );
 835
 836
 837         vst.finalize();
 838
 839         //replicationエリアを開放する
 840         debugg_flug_struct::getInstance().destroy_rep_area();
 841 }
 842
 843 //組み合わせアクセステスト
 844 void    virtualservice_tcp_test2(){
 845         //replicationエリアを作成しておく
 846         debugg_flug_struct::getInstance().create_rep_area();
 847
 848         boost::asio::io_service         dispatcher;
 849
 850         l7vs::l7vsd                                     vsd;
 851         l7vs::replication                       rep();
 852
 853         debugg_flug_struct::getInstance().pmcontrol_err_flag()  = false;
 854         debugg_flug_struct::getInstance().smcontrol_err_flag()  = false;
 855         debugg_flug_struct::getInstance().param_exist_flag() = false;
 856
 857         l7vs::error_code                        vs_err;
 858         boost::system::error_code       test_err;
 859
 860         std::stringstream       tmp_tcp_ep;
 861         std::stringstream       tmp_udp_ep;
 862         std::stringstream       tmp_sorry_ep;
 863
 864         l7vs::virtualservice_element    elem1;
 865
 866         //set element value
 867         elem1.udpmode                                   = false;
 868         elem1.tcp_accept_endpoint               =
 869                         tcp_ep_type( boost::asio::ip::address_v4::loopback(), (60000) );
 870         elem1.udp_recv_endpoint                 = udp_ep_type( boost::asio::ip::address::from_string( "10.144.169.20" ), (50000) );
 871         elem1.realserver_vector.clear();
 872         elem1.protocol_module_name              = "PMtest1";
 873         elem1.schedule_module_name              = "SMtest1";
 874         elem1.protocol_args.clear();
 875         elem1.sorry_maxconnection               = 1234LL;
 876         elem1.sorry_endpoint                    = tcp_ep_type();
 877         elem1.sorry_flag                                = false;
 878         elem1.qos_upstream                              = 65535ULL;
 879         elem1.qos_downstream                    = 32767ULL;
 880
 881         //vs作成
 882         vs_access       vst;
 883         vst.initialize( elem1 );
 884         vst.get_vs()->initialize( vs_err );
 885         //待ち受け開始
 886         boost::thread   vs_run( &vs_access::run, &vst );
 887         usleep( 1000 );
 888
 889         // unit_test[24]  sessionがActiveになるときに、release_sessionされるケース
 890         // unit_test[25]  sessionがActiveになるときにfinalize
 891         // unit_test[26]  release_sessionされるときにfinalize
 892         std::cout << counter++ << std::endl;
 893         std::cout << counter++ << std::endl;
 894         std::cout << counter++ << std::endl;
 895         // finalizeを呼べば、stopされてrelease_sessionされる。
 896         {
 897                 boost::thread   thread1( &vs_access::client, &vst );
 898                 boost::thread   thread2( &vs_access::vs_finalize, &vst );
 899
 900                 usleep( 100000 );
 901                 vst.start();
 902                 usleep( 1000 );
 903                 thread1.join();
 904                 thread2.join();
 905         }
 906
 907         vst.get_vs()->stop();
 908         usleep( 1000 );
 909         vs_run.join();
 910
 911         vst.finalize();
 912         usleep( 1000 );
 913
 914         //replicationエリアを開放する
 915         debugg_flug_struct::getInstance().destroy_rep_area();
 916 }
 917
 918 void    virtualservice_tcp_test3(){
 919         //replicationエリアを作成しておく
 920         debugg_flug_struct::getInstance().create_rep_area();
 921
 922 //      boost::asio::io_service         dispatcher;
 923
 924         l7vs::l7vsd                                     vsd;
 925         l7vs::replication                       rep();
 926
 927         debugg_flug_struct::getInstance().pmcontrol_err_flag()  = false;
 928         debugg_flug_struct::getInstance().smcontrol_err_flag()  = false;
 929         debugg_flug_struct::getInstance().param_exist_flag() = false;
 930
 931         l7vs::error_code                        vs_err;
 932         boost::system::error_code       test_err;
 933
 934         std::stringstream       tmp_tcp_ep;
 935         std::stringstream       tmp_udp_ep;
 936         std::stringstream       tmp_sorry_ep;
 937
 938         l7vs::virtualservice_element    elem1;
 939
 940         //set element value
 941         elem1.udpmode                                   = false;
 942         elem1.tcp_accept_endpoint               =
 943                         tcp_ep_type( boost::asio::ip::address_v4::loopback(), (60000) );
 944         elem1.udp_recv_endpoint                 = udp_ep_type( boost::asio::ip::address::from_string( "10.144.169.20" ), (50000) );
 945         elem1.realserver_vector.clear();
 946         elem1.protocol_module_name              = "PMtest1";
 947         elem1.schedule_module_name              = "SMtest1";
 948         elem1.protocol_args.clear();
 949         elem1.sorry_maxconnection               = 1234LL;
 950         elem1.sorry_endpoint                    = tcp_ep_type();
 951         elem1.sorry_flag                                = false;
 952         elem1.qos_upstream                              = 65535ULL;
 953         elem1.qos_downstream                    = 32767ULL;
 954
 955         //vs作成
 956         vs_access       vst;
 957         vst.initialize( elem1 );
 958
 959         //rs追加
 960         // unit_test[27]  add_rsとrs_list_lock
 961         std::cout << counter++ << std::endl;
 962         //RS追加用のelement準備
 963         l7vs::virtualservice_element    elem2;
 964         //set element value
 965         elem2.udpmode                                   = false;
 966         elem2.tcp_accept_endpoint               =
 967                         tcp_ep_type( boost::asio::ip::address_v4::loopback(), (60000) );
 968         elem2.udp_recv_endpoint                 = udp_ep_type( boost::asio::ip::address::from_string( "10.144.169.20" ), (50000) );
 969         elem2.realserver_vector.clear();
 970         elem2.protocol_module_name              = "PMtest1";
 971         elem2.schedule_module_name              = "SMtest1";
 972         elem2.protocol_args.clear();
 973         elem2.sorry_maxconnection               = 1234LL;
 974         elem2.sorry_endpoint                    = tcp_ep_type();
 975         elem2.sorry_flag                                = false;
 976         elem2.qos_upstream                              = 65535ULL;
 977         elem2.qos_downstream                    = 32767ULL;
 978         for( size_t i = 0; i < 2; ++i ){
 979                 l7vs::realserver_element        rs_elem;
 980                 rs_elem.tcp_endpoint = tcp_ep_type( boost::asio::ip::address::from_string( "192.168.10.10" ), (i+8080) );
 981                 rs_elem.weight  = 10+i;
 982                 elem2.realserver_vector.push_back( rs_elem );
 983         }
 984         {
 985                 boost::thread   thread1( &vs_access::rs_list_lock, &vst );
 986                 boost::thread   thread2( &vs_access::add_realserver, &vst, elem2 );
 987
 988                 usleep( 100000 );
 989                 vst.start();
 990                 usleep( 1000 );
 991                 BOOST_CHECK( vst.get_vs()->get_ref_count() == 1 );
 992                 //ref_countが1のままだとadd_realserverができないのでunlockする
 993                 vst.get_vs()->rs_list_unlock();
 994                 usleep( 100000 );
 995                 thread1.join();
 996                 thread2.join();
 997         }
 998         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 2 );
 999         BOOST_CHECK( vst.get_vs()->get_ref_count() == 0 );
1000
1001         //一旦削除
1002         vst.get_vs()->del_realserver( elem2, vs_err );
1003
1004         // unit_test[28]  add_rsとrs_list_unlock(ref_countが1でスタートした場合)
1005         std::cout << counter++ << std::endl;
1006         {
1007                 //あらかじめlockしておいてref_countを1にしておく
1008                 vst.get_vs()->rs_list_lock();
1009                 BOOST_CHECK( vst.get_vs()->get_ref_count() == 1 );
1010
1011                 boost::thread   thread1( &vs_access::add_realserver, &vst, elem2 );
1012                 boost::thread   thread2( &vs_access::rs_list_unlock, &vst );
1013
1014                 usleep( 100000 );
1015                 vst.start();
1016                 usleep( 1000 );
1017                 thread1.join();
1018                 thread2.join();
1019         }
1020         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 2 );
1021         BOOST_CHECK( vst.get_vs()->get_ref_count() == 0 );
1022
1023         // unit_test[29]  add_rsとconnection_active
1024         std::cout << counter++ << std::endl;
1025         //RS追加用のelement準備
1026         l7vs::virtualservice_element    elem3;
1027         //set element value
1028         elem3.udpmode                                   = false;
1029         elem3.tcp_accept_endpoint               =
1030                         tcp_ep_type( boost::asio::ip::address_v4::loopback(), (60000) );
1031         elem3.udp_recv_endpoint                 = udp_ep_type( boost::asio::ip::address::from_string( "10.144.169.20" ), (50000) );
1032         elem3.realserver_vector.clear();
1033         elem3.protocol_module_name              = "PMtest1";
1034         elem3.schedule_module_name              = "SMtest1";
1035         elem3.protocol_args.clear();
1036         elem3.sorry_maxconnection               = 1234LL;
1037         elem3.sorry_endpoint                    = tcp_ep_type();
1038         elem3.sorry_flag                                = false;
1039         elem3.qos_upstream                              = 65535ULL;
1040         elem3.qos_downstream                    = 32767ULL;
1041         for( size_t i = 0; i < 2; ++i ){
1042                 l7vs::realserver_element        rs_elem;
1043                 rs_elem.tcp_endpoint = tcp_ep_type( boost::asio::ip::address::from_string( "192.168.10.10" ), (i+8090) );
1044                 rs_elem.weight  = 5+i;
1045                 elem3.realserver_vector.push_back( rs_elem );
1046         }
1047         {
1048                 boost::thread   thread1( &vs_access::add_realserver, &vst, elem3 );
1049                 boost::thread   thread2( &vs_access::connection_active, &vst, elem2.realserver_vector[0].tcp_endpoint );
1050
1051                 usleep( 100000 );
1052                 vst.start();
1053                 usleep( 1000 );
1054
1055                 thread1.join();
1056                 thread2.join();
1057         }
1058         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 4 );
1059         for( std::list<l7vs::realserver>::iterator itr = vst.get_vs()->get_rs_list().begin();
1060                  itr != vst.get_vs()->get_rs_list().end(); ++itr ){
1061                 if( itr->tcp_endpoint == elem2.realserver_vector[0].tcp_endpoint ){
1062                         std::cout << "active_conn check" << std::endl;
1063                         BOOST_CHECK( itr->get_active() == 1 );
1064                         BOOST_CHECK( itr->get_inact() == 0 );
1065                         break;
1066                 }
1067         }
1068
1069         //一旦削除
1070         vst.get_vs()->del_realserver( elem3, vs_err );
1071
1072         // unit_test[30]  add_rsとconnection_inactive
1073         std::cout << counter++ << std::endl;
1074         {
1075                 boost::thread   thread1( &vs_access::add_realserver, &vst, elem3 );
1076                 boost::thread   thread2( &vs_access::connection_inactive, &vst, elem2.realserver_vector[0].tcp_endpoint );
1077
1078                 usleep( 100000 );
1079                 vst.start();
1080                 usleep( 1000 );
1081
1082                 thread1.join();
1083                 thread2.join();
1084         }
1085         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 4 );
1086         for( std::list<l7vs::realserver>::iterator itr = vst.get_vs()->get_rs_list().begin();
1087                  itr != vst.get_vs()->get_rs_list().end(); ++itr ){
1088                 if( itr->tcp_endpoint == elem2.realserver_vector[0].tcp_endpoint ){
1089                         std::cout << "inactive_conn check" << std::endl;
1090                         BOOST_CHECK( itr->get_active() == 0 );
1091                         BOOST_CHECK( itr->get_inact() == 1 );
1092                         break;
1093                 }
1094         }
1095
1096         //rs変更
1097         // unit_test[31]  edit_rsとrs_list_lock
1098         std::cout << counter++ << std::endl;
1099         //RS編集用のelement準備
1100         l7vs::virtualservice_element    elem4;
1101         //set element value
1102         elem4.udpmode                                   = false;
1103         elem4.tcp_accept_endpoint               =
1104                         tcp_ep_type( boost::asio::ip::address_v4::loopback(), (60000) );
1105         elem4.udp_recv_endpoint                 = udp_ep_type( boost::asio::ip::address::from_string( "10.144.169.20" ), (50000) );
1106         elem4.realserver_vector.clear();
1107         elem4.protocol_module_name              = "PMtest1";
1108         elem4.schedule_module_name              = "SMtest1";
1109         elem4.protocol_args.clear();
1110         elem4.sorry_maxconnection               = 1234LL;
1111         elem4.sorry_endpoint                    = tcp_ep_type();
1112         elem4.sorry_flag                                = false;
1113         elem4.qos_upstream                              = 65535ULL;
1114         elem4.qos_downstream                    = 32767ULL;
1115         for( size_t i = 0; i < 2; ++i ){
1116                 l7vs::realserver_element        rs_elem;
1117                 rs_elem.tcp_endpoint = tcp_ep_type( boost::asio::ip::address::from_string( "192.168.10.10" ), (i+8080) );
1118                 rs_elem.weight  = 5+i;
1119                 elem4.realserver_vector.push_back( rs_elem );
1120         }
1121         {
1122                 boost::thread   thread1( &vs_access::edit_realserver, &vst, elem4 );
1123                 boost::thread   thread2( &vs_access::rs_list_lock, &vst );
1124
1125                 usleep( 100000 );
1126                 vst.start();
1127                 usleep( 1000 );
1128                 BOOST_CHECK( vst.get_vs()->get_ref_count() == 1 );
1129                 //ref_countが1のままだとedit_realserverができないのでunlockする
1130                 vst.get_vs()->rs_list_unlock();
1131                 BOOST_CHECK( vst.get_vs()->get_ref_count() == 0 );
1132                 usleep( 100000 );
1133                 thread1.join();
1134                 thread2.join();
1135         }
1136         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 4 );
1137
1138         // unit_test[32]  edit_rsとrs_list_unlock
1139         std::cout << counter++ << std::endl;
1140         {
1141                 //あらかじめlockしておいてref_countを1にしておく
1142                 vst.get_vs()->rs_list_lock();
1143                 BOOST_CHECK( vst.get_vs()->get_ref_count() == 1 );
1144
1145                 boost::thread   thread1( &vs_access::edit_realserver, &vst, elem2 );
1146                 boost::thread   thread2( &vs_access::rs_list_unlock, &vst );
1147                 usleep( 100000 );
1148                 vst.start();
1149                 usleep( 1000 );
1150                 thread1.join();
1151                 thread2.join();
1152         }
1153         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 4 );
1154         BOOST_CHECK( vst.get_vs()->get_ref_count() == 0 );
1155
1156         // unit_test[33]  edit_rsとconnection_active
1157         std::cout << counter++ << std::endl;
1158         elem4.realserver_vector.clear();
1159         for( size_t i = 0; i < 2; ++i ){
1160                 l7vs::realserver_element        rs_elem;
1161                 rs_elem.tcp_endpoint = tcp_ep_type( boost::asio::ip::address::from_string( "192.168.10.10" ), (i+8080) );
1162                 rs_elem.weight  = 100+i;
1163                 elem4.realserver_vector.push_back( rs_elem );
1164         }
1165         {
1166                 boost::thread   thread1( &vs_access::edit_realserver, &vst, elem4 );
1167                 boost::thread   thread2( &vs_access::connection_active, &vst, elem2.realserver_vector[0].tcp_endpoint );
1168
1169                 usleep( 100000 );
1170                 vst.start();
1171                 usleep( 1000 );
1172
1173                 thread1.join();
1174                 thread2.join();
1175         }
1176         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 4 );
1177         for( std::list<l7vs::realserver>::iterator itr = vst.get_vs()->get_rs_list().begin();
1178                  itr != vst.get_vs()->get_rs_list().end(); ++itr ){
1179                 if( itr->tcp_endpoint == elem2.realserver_vector[0].tcp_endpoint ){
1180                         std::cout << "active_conn check" << std::endl;
1181                         BOOST_CHECK( itr->get_active() == 1 );
1182                         BOOST_CHECK( itr->get_inact() == 1 );
1183                         break;
1184                 }
1185         }
1186         // unit_test[34]  edit_rsとconnection_inactive
1187         std::cout << counter++ << std::endl;
1188         {
1189                 boost::thread   thread1( &vs_access::edit_realserver, &vst, elem4 );
1190                 boost::thread   thread2( &vs_access::connection_inactive, &vst, elem2.realserver_vector[0].tcp_endpoint );
1191
1192                 usleep( 100000 );
1193                 vst.start();
1194                 usleep( 1000 );
1195
1196                 thread1.join();
1197                 thread2.join();
1198         }
1199         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 4 );
1200         for( std::list<l7vs::realserver>::iterator itr = vst.get_vs()->get_rs_list().begin();
1201                  itr != vst.get_vs()->get_rs_list().end(); ++itr ){
1202                 if( itr->tcp_endpoint == elem2.realserver_vector[0].tcp_endpoint ){
1203                         std::cout << "inactive_conn check" << std::endl;
1204                         BOOST_CHECK( itr->get_active() == 0 );
1205                         BOOST_CHECK( itr->get_inact() == 2 );
1206                         break;
1207                 }
1208         }
1209
1210         //rs削除
1211         // unit_test[35]  del_rsとrs_list_lock
1212         std::cout << counter++ << std::endl;
1213         {
1214                 boost::thread   thread1( &vs_access::del_realserver, &vst, elem4 );
1215                 boost::thread   thread2( &vs_access::rs_list_lock, &vst );
1216
1217                 usleep( 100000 );
1218                 vst.start();
1219                 usleep( 1000 );
1220                 BOOST_CHECK( vst.get_vs()->get_ref_count() == 1 );
1221                 //ref_countが1のままだとedit_realserverができないのでunlockする
1222                 vst.get_vs()->rs_list_unlock();
1223                 BOOST_CHECK( vst.get_vs()->get_ref_count() == 0 );
1224                 usleep( 100000 );
1225                 thread1.join();
1226                 thread2.join();
1227         }
1228         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 2 );
1229
1230         //再度追加
1231         vst.get_vs()->add_realserver( elem4, vs_err );
1232
1233         // unit_test[36]  del_rsとrs_list_unlock
1234         std::cout << counter++ << std::endl;
1235         {
1236                 //あらかじめlockしておいてref_countを1にしておく
1237                 vst.get_vs()->rs_list_lock();
1238                 BOOST_CHECK( vst.get_vs()->get_ref_count() == 1 );
1239
1240                 boost::thread   thread1( &vs_access::del_realserver, &vst, elem4 );
1241                 boost::thread   thread2( &vs_access::rs_list_unlock, &vst );
1242                 usleep( 100000 );
1243                 vst.start();
1244                 usleep( 1000 );
1245                 thread1.join();
1246                 thread2.join();
1247         }
1248         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 2 );
1249         BOOST_CHECK( vst.get_vs()->get_ref_count() == 0 );
1250
1251         //再度追加
1252         vst.get_vs()->add_realserver( elem4, vs_err );
1253
1254         //del_rsとconnection_active
1255         {
1256                 boost::thread   thread1( &vs_access::del_realserver, &vst, elem4 );
1257                 boost::thread   thread2( &vs_access::connection_active, &vst, elem3.realserver_vector[0].tcp_endpoint );
1258
1259                 usleep( 100000 );
1260                 vst.start();
1261                 usleep( 1000 );
1262
1263                 thread1.join();
1264                 thread2.join();
1265         }
1266         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 2 );
1267         for( std::list<l7vs::realserver>::iterator itr = vst.get_vs()->get_rs_list().begin();
1268                  itr != vst.get_vs()->get_rs_list().end(); ++itr ){
1269                 if( itr->tcp_endpoint == elem2.realserver_vector[0].tcp_endpoint ){
1270                         std::cout << "active_conn check" << std::endl;
1271                         BOOST_CHECK( itr->get_active() == 1 );
1272                         BOOST_CHECK( itr->get_inact() == 0 );
1273                         break;
1274                 }
1275         }
1276
1277         //再度追加
1278         vst.get_vs()->add_realserver( elem4, vs_err );
1279         //del_rsとconnection_inactive
1280         {
1281                 boost::thread   thread1( &vs_access::del_realserver, &vst, elem4 );
1282                 boost::thread   thread2( &vs_access::connection_inactive, &vst, elem3.realserver_vector[0].tcp_endpoint );
1283
1284                 usleep( 100000 );
1285                 vst.start();
1286                 usleep( 1000 );
1287
1288                 thread1.join();
1289                 thread2.join();
1290         }
1291         BOOST_CHECK( vst.get_vs()->get_rs_list().size() == 2 );
1292         for( std::list<l7vs::realserver>::iterator itr = vst.get_vs()->get_rs_list().begin();
1293                  itr != vst.get_vs()->get_rs_list().end(); ++itr ){
1294                 if( itr->tcp_endpoint == elem2.realserver_vector[0].tcp_endpoint ){
1295                         std::cout << "inactive_conn check" << std::endl;
1296                         BOOST_CHECK( itr->get_active() == 0 );
1297                         BOOST_CHECK( itr->get_inact() == 1 );
1298                         break;
1299                 }
1300         }
1301
1302         vst.finalize();
1303         //replicationエリアを開放する
1304         debugg_flug_struct::getInstance().destroy_rep_area();
1305 }
1306
1307
1308 test_suite*     init_unit_test_suite( int argc, char* argv[] ){
1309
1310         // create unit test suite
1311         test_suite* ts = BOOST_TEST_SUITE( "virtualservice_base_test" );
1312
1313         // add test case to test suite
1314         ts->add( BOOST_TEST_CASE( &virtualservice_tcp_test1 ) );
1315         ts->add( BOOST_TEST_CASE( &virtualservice_tcp_test2 ) );
1316 //      ts->add( BOOST_TEST_CASE( &virtualservice_tcp_test3 ) );
1317
1318         framework::master_test_suite().add( ts );
1319
1320         return 0;
1321 }