l7vsd/unit_tests/replication_test/replication_test.cpp

   1 #include    <iostream>
   2 #include    <boost/test/included/unit_test.hpp>
   3 #include    <boost/test/parameterized_test.hpp>
   4 #include    "replication.h"
   5 #include    "logger.h"
   6 #include    "parameter.h"
   7 #include    <malloc.h>
   8 #include    <boost/algorithm/string.hpp>
   9
  10 #define     TARGET_IP_V4        "127.0.0.1"
  11 #define     TARGET_IP_V6        "[::1]"
  12 #define     TARGET_HOSTNAME     "um08"
  13 #define     REPLICATION_PORT    "40000"
  14 #define     RECV_IP_V4          "127.0.01"
  15 #define     RECV_IP_V6          "[::1]"
  16
  17 int get_string_stubmode = 0;
  18 int get_int_stubmode = 0;
  19
  20 char    target_ip_table[][256] = {
  21     TARGET_IP_V4,
  22     TARGET_IP_V6
  23 };
  24
  25 char    recv_ip_table[][256] = {
  26     RECV_IP_V4,
  27     RECV_IP_V6
  28 };
  29
  30 char    get_string_table[][ 256 ] = {
  31     TARGET_IP_V4,                //    "ip_addr"
  32     REPLICATION_PORT,                    //    "service_name"
  33     RECV_IP_V4,                        //    "recv_ip_addr"
  34     "virtualservice",            //    "cmponent_id_00"
  35     "chash",                    //    "cmponent_id_01"
  36     "sslid",                    //    "cmponent_id_02"
  37 };
  38
  39 int        get_int_table[] = {
  40     10000,                        //    "interval"
  41     64,                            //    "cmponent_size_00"
  42     1,                            //    "cmponent_size_01"
  43     200,                        //    "cmponent_size_02"
  44     10                            //    "compulsorily_interval"
  45 };
  46
  47
  48 #include    "logger_stub.cpp"
  49 #include    "parameter_stub.cpp"
  50
  51 //class    l7vs::replication;
  52
  53 using namespace boost::unit_test;
  54
  55 //! endpoint string parse function
  56 //! @param[in]      endpoint string
  57 //! @return         endpoint
  58 template < class T >
  59 typename T::endpoint make_endpoint( const char*  in_host, const char* in_port ){
  60     std::string hostname(in_host);
  61     std::string portname(in_port);
  62
  63     //remove "[","]"
  64     boost::algorithm::erase_first( hostname, "[" );
  65     boost::algorithm::erase_last( hostname, "]" );
  66
  67     boost::asio::io_service         io_service;
  68     typename T::resolver            resolver(io_service);
  69     typename T::resolver::query     query( hostname, portname );
  70     typename T::resolver::iterator  end;
  71     boost::system::error_code       ec;
  72     typename T::resolver::iterator  itr = resolver.resolve( query, ec );
  73     if( ec ){
  74         return typename T::endpoint();
  75     }
  76     if( itr == end ) return typename T::endpoint();
  77     return *itr;
  78 }
  79
  80 namespace l7vs{
  81
  82 class replication_fake : public replication
  83 {
  84 public:
  85     //!    constractor
  86     replication_fake() : replication() {}
  87     //! destractor
  88     ~replication_fake(){}
  89
  90     bool    locked( const std::string& inid ){
  91         std::map<std::string, mutex_ptr>::iterator    itr;
  92         bool    res;
  93
  94         itr = replication_mutex.find( inid );
  95         if( itr == replication_mutex.end() ){
  96             return false;
  97         }
  98
  99         res = itr->second->try_lock();
 100         if ( res ){
 101             itr->second->unlock();
 102         }
 103         return !res;
 104     }
 105
 106     int        set_master_wrapper(){
 107         return set_master();
 108     }
 109
 110     int        set_slave_wrapper(){
 111
 112         {
 113             boost::mutex::scoped_lock    lock( replication_thread_mutex );
 114             if    ( replication_flag != EXIT ){
 115                  replication_flag = WAIT;
 116             }
 117         }
 118
 119         return set_slave();
 120     }
 121
 122     int        check_parameter_wrapper(){
 123         return check_parameter();
 124     }
 125
 126     void*    getrpl_wrapper(){
 127         replication_state.replication_memory = getrpl();
 128         return replication_state.replication_memory;
 129     }
 130
 131     void*    getcmp_wrapper(){
 132         replication_state.component_memory = getcmp();
 133         return replication_state.component_memory;
 134     }
 135
 136     uint64_t*    getsrf_wrapper(){
 137         replication_state.surface_block_array_ptr = getsrf();
 138         return replication_state.surface_block_array_ptr;
 139     }
 140
 141     unsigned long long            make_serial_wrapper(){
 142         return make_serial();
 143     }
 144
 145
 146     void*        releaserpl_wrapper(){
 147         releaserpl();
 148         return replication_state.replication_memory;
 149     }
 150
 151     void*        releasecmp_wrapper(){
 152         releasecmp();
 153         return replication_state.component_memory;
 154     }
 155
 156     uint64_t*    releasesrf_wrapper(){
 157         releasesrf();
 158         return replication_state.surface_block_array_ptr;
 159     }
 160
 161     void        disable_send_thread(){
 162         {
 163             boost::mutex::scoped_lock    lock( replication_thread_mutex );
 164
 165             replication_flag = EXIT;
 166             replication_thread_condition.notify_all();
 167         }
 168         if ( replication_thread_ptr ){
 169             replication_thread_ptr->join();
 170         }
 171     }
 172 };
 173
 174 }    //namespace l7vs
 175
 176 int        count = 0;
 177
 178 extern "C"
 179 {
 180     extern void* _start;
 181     extern void* _etext;
 182     //--------------------------- mallocスタブ関数 --------------------------------------
 183     static void*            malloc_dbg(size_t, const void *);
 184     static void                malloc_dbg_install();
 185     static void                malloc_dbg_uninstall();
 186     static void*            (*old_malloc_hook)(size_t, const void *);
 187
 188     static void malloc_dbg_install ()
 189     {
 190         old_malloc_hook = __malloc_hook;
 191         __malloc_hook = malloc_dbg;
 192     }
 193
 194     static void malloc_dbg_uninstall ()
 195     {
 196         __malloc_hook = old_malloc_hook;
 197     }
 198
 199     //mallocデバッグ
 200     int        malloc_count = 0;
 201
 202     static void * malloc_dbg(size_t size, const void *caller){
 203         void *ret;
 204
 205         if((&_start < caller) && (caller < &_etext)){
 206             if (0 < malloc_count){
 207                 --malloc_count;
 208                 malloc_dbg_uninstall();
 209                 ret = malloc(size);
 210                 malloc_dbg_install();
 211                 return ret;
 212             } else {
 213                 return NULL;
 214             }
 215         } else {
 216             malloc_dbg_uninstall();
 217             ret = malloc(size);
 218             malloc_dbg_install();
 219             return ret;
 220         }
 221     }
 222 }
 223
 224 //! emun States Type string
 225 static const char* replication_mode[] = {
 226     "REPLICATION_OUT",
 227     "REPLICATION_SINGLE",
 228     "REPLICATION_MASTER",
 229     "REPLICATION_SLAVE",
 230     "REPLICATION_MASTER_STOP",
 231     "REPLICATION_SLAVE_STOP"
 232 };
 233
 234 volatile bool locked_end = false;
 235
 236 volatile bool receiver_end = false;
 237 boost::asio::io_service global_receive_io;
 238 boost::asio::io_service global_send_io;
 239
 240 void receiver_thread( const char* recv_ip ){
 241     //boost::asio::ip::udp::endpoint    udp_endpoint( boost::asio::ip::address::from_string( recv_ip ), 40000 );
 242     boost::asio::ip::udp::endpoint      udp_endpoint( make_endpoint<boost::asio::ip::udp>( recv_ip, REPLICATION_PORT ) );
 243     boost::asio::ip::udp::socket        receiver_socket( global_receive_io, udp_endpoint );
 244
 245     char    *recv_memory;
 246     size_t    size;
 247
 248     //! Transfer data between active server and standby server.
 249     struct replication_data_struct{
 250         unsigned short                    id;                            //!< ID of Replication Function
 251         char                            pad1[6];
 252         unsigned long long                serial;                        //!< Serial Number
 253         unsigned int                    block_num;                    //!< Block Number in Replication memory
 254         char                            pad2[4];
 255         uint64_t                        size;                        //!< Data size for checking packet loss
 256         char                            data[DATA_SIZE];            //!< Raw data
 257     } replication_data;
 258
 259     //! State Infomation struct to execute Replication.
 260     struct replication_state_struct{
 261         enum l7vs::replication::REPLICATION_MODE_TAG        service_status;                //!< States Type of Replication Function
 262         unsigned long long                send_time;                    //!< Completion last time to send data(no use)
 263         unsigned int                    last_send_block;            //!< Completion last Block Number to send data
 264         unsigned int                    last_recv_block;            //!< Completion last Block Number to receive data
 265         unsigned int                    total_block;                //!< The maximum Block Number of Components memory
 266         void*                            replication_memory;            //!< Top address in Replication memory
 267         void*                            component_memory;            //!< Top address in Component memory
 268         uint64_t                        surface_block_no;            //!< Serial number for respect switch
 269         uint64_t*                        surface_block_array_ptr;    //!< Serial number in received respect at every block
 270
 271         replication_state_struct() :    service_status(l7vs::replication::REPLICATION_OUT),
 272                                         send_time(0),
 273                                         last_send_block(0),
 274                                         last_recv_block(0),
 275                                         total_block(0),
 276                                         replication_memory(NULL),
 277                                         component_memory(NULL),
 278                                         surface_block_no(0),
 279                                         surface_block_array_ptr(NULL) {}
 280     } replication_state;
 281
 282
 283     l7vs::Parameter    param;
 284     std::string key_id;
 285     std::string key_size;
 286     l7vs::error_code    size_ret;
 287
 288     // Conponent exists
 289     // Get Component infomation
 290     for ( int i=0; i<CMP_MAX; i++)    {
 291         key_size = boost::io::str( boost::format( "cmponent_size_%02d" ) % i );
 292         replication_state.total_block += param.get_int( l7vs::PARAM_COMP_REPLICATION, key_size, size_ret );
 293     }
 294
 295     // Replication memory is NULL
 296     if ( NULL == ( replication_state.replication_memory = malloc( replication_state.total_block*DATA_SIZE ) ))    {
 297         l7vs::Logger::putLogError( l7vs::LOG_CAT_L7VSD_SYSTEM_MEMORY, 1, "Replication memory is NULL.", __FILE__, __LINE__ );
 298         goto END;
 299     }
 300 //    memset(replication_state.replication_memory,0,replication_state.total_block*DATA_SIZE);
 301     memset(replication_state.replication_memory,'9',replication_state.total_block*DATA_SIZE);
 302
 303
 304     // Component memory is NULL
 305 //    if ( NULL == ( replication_state.component_memory = malloc( replication_state.total_block*DATA_SIZE ) ) ){
 306 //        l7vs::Logger::putLogError( l7vs::LOG_CAT_L7VSD_SYSTEM_MEMORY, 1, "Component memory is NULL.", __FILE__, __LINE__ );
 307 //        goto END;
 308 //    }
 309 //    memset(replication_state.component_memory,0,replication_state.total_block*DATA_SIZE);
 310
 311     // Surface block array memory is NULL
 312     if ( NULL == ( replication_state.surface_block_array_ptr = ( uint64_t* )malloc( replication_state.total_block*sizeof(uint64_t) ) ))    {
 313         l7vs::Logger::putLogError( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, "Surface block array pointer is NULL.", __FILE__, __LINE__ );
 314         goto END;
 315     }
 316     memset(replication_state.surface_block_array_ptr,0,replication_state.total_block*sizeof(uint64_t));
 317
 318     for ( ; ; ){
 319 //        size = receiver_socket.receive_from ( boost::asio::buffer( &replication_data, sizeof( struct replication_data_struct ) ), udp_endpoint );
 320         size = receiver_socket.receive ( boost::asio::buffer( &replication_data, sizeof( struct replication_data_struct ) ) );
 321         if ( size != sizeof ( struct replication_data_struct ) ){
 322             l7vs::Logger::putLogError( l7vs::LOG_CAT_L7VSD_SYSTEM, 1, "Failed in the reception processing of data because of illegal receive size.", __FILE__, __LINE__ );
 323             goto END;
 324         }
 325
 326 //std::cout << "receiver_thread\n";
 327 //std::cout << replication_data.id << "\n";
 328 //std::cout << replication_data.serial << "\n";
 329 //std::cout << replication_data.block_num << "\n";
 330 //std::cout << replication_data.size << "\n";
 331 //std::cout << replication_data.data[0] << "\n";
 332
 333         // Check replication ID
 334         if ( replication_data.id != REPLICATION_ID ){
 335             l7vs::Logger::putLogError( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, "Get invalid data.", __FILE__, __LINE__ );
 336             goto END;
 337         } else if ( replication_data.block_num > replication_state.total_block ){
 338             // block number is over
 339             l7vs::Logger::putLogError( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, "Recv block number is too large.", __FILE__, __LINE__ );
 340             goto END;
 341         } else if ( replication_data.serial < replication_state.surface_block_array_ptr[replication_data.block_num] ){
 342             // Comparison of serial numbers
 343             l7vs::Logger::putLogError( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, "Recv replication data is too old.", __FILE__, __LINE__ );
 344             goto END;
 345         } else {
 346             // Substitution of version
 347             replication_state.surface_block_array_ptr[replication_data.block_num] = replication_data.serial;
 348         }
 349
 350         // set recv data
 351         recv_memory = ( char * )replication_state.replication_memory + DATA_SIZE * replication_data.block_num;
 352
 353         // received data.
 354         memcpy( recv_memory, &replication_data.data, DATA_SIZE );
 355
 356         // set surface block
 357         replication_state.surface_block_array_ptr[replication_data.block_num] = replication_data.serial;
 358
 359         // Surface numbers are compared.
 360         for ( unsigned int i = 0; i < replication_state.total_block-1; i++ ){
 361             if ( replication_state.surface_block_array_ptr[i] != replication_state.surface_block_array_ptr[i+1] ){
 362                 break;
 363             }
 364             if ( i == replication_state.total_block-2 ){
 365                 // Synchronization is executed.
 366 //                memcpy(replication_state.component_memory, replication_state.replication_memory, replication_state.total_block*DATA_SIZE );
 367                 l7vs::Logger::putLogInfo( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, "Replication stub receiving is success.", __FILE__, __LINE__ );
 368
 369                 int size;
 370                 unsigned char* p;
 371                 unsigned char* head;
 372                 int h = 0;
 373                 int i = 0;
 374                 std::string    buf;
 375
 376                 // Dump size
 377                 size = DATA_SIZE * replication_state.total_block;
 378
 379                 // Memory Dump
 380                 p = ( unsigned char * )replication_state.replication_memory;
 381
 382                 // Output mode
 383                 l7vs::Logger::putLogInfo( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, "Replication check Start ----------------------------", __FILE__, __LINE__ );
 384                 buf = boost::io::str( boost::format( "Mode is [ %s ]." ) % replication_mode[(int)replication_state.service_status] );
 385                 l7vs::Logger::putLogInfo( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, buf, __FILE__, __LINE__ );
 386                 buf = boost::io::str( boost::format( "Total Block is [ %u ]" ) % replication_state.total_block );
 387                 l7vs::Logger::putLogInfo( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, buf, __FILE__, __LINE__ );
 388
 389                 // Converts into the binary, and writes it to the file.
 390                 for ( h = 0; h < size / DATA_SIZE; h++ ){
 391                     buf = boost::io::str( boost::format( "Block Number [ %d ]" ) % h );
 392                     l7vs::Logger::putLogInfo( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, buf, __FILE__, __LINE__ );
 393
 394                     for ( i = 0; i < DATA_SIZE / LOG_DATA_WIDTH; i++ ){
 395                         head = p + h * DATA_SIZE + i * LOG_DATA_WIDTH;
 396
 397                         // have to cast char to int. because boost::format ignore char with appointed width.
 398                         buf = boost::io::str( boost::format(    "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX  "
 399                                                                 "%02hhX %02hhX %02hhX %02hhX  %02hhX %02hhX %02hhX %02hhX" )
 400                                                                 % ( int )*head % ( int )*(head+1) % ( int )*(head+2) % ( int )*(head+3)
 401                                                                 % ( int )*(head+4) % ( int )*(head+5) % ( int )*(head+6)% ( int )*(head+7)
 402                                                                 % ( int )*(head+8) % ( int )*(head+9) % ( int )*(head+10) % ( int )*(head+11)
 403                                                                 % ( int )*(head+12) % ( int )*(head+13) % ( int )*(head+14) % ( int )*(head+15) );
 404                         l7vs::Logger::putLogInfo( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, buf, __FILE__, __LINE__ );
 405                     }
 406                 }
 407                 l7vs::Logger::putLogInfo( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, "Replication check End ------------------------------", __FILE__, __LINE__ );
 408
 409                 goto END;
 410             }
 411         }
 412
 413         // set surface block
 414         replication_state.surface_block_array_ptr[replication_data.block_num] = replication_data.serial;
 415
 416         // set last recv block number
 417         if ( replication_state.last_recv_block < replication_state.total_block-1 ){
 418             replication_state.last_recv_block += 1;
 419         }else if(replication_state.last_recv_block == replication_state.total_block-1){
 420             replication_state.last_recv_block = 0;
 421         }else{
 422             l7vs::Logger::putLogError( l7vs::LOG_CAT_L7VSD_REPLICATION, 1, "Last send block number is illegal.", __FILE__, __LINE__ );
 423             goto END;
 424         }
 425     }
 426
 427 END:
 428     if ( NULL != replication_state.replication_memory){
 429         free(replication_state.replication_memory);
 430     }
 431     replication_state.replication_memory = NULL;
 432     if ( NULL != replication_state.component_memory){
 433         free(replication_state.component_memory);
 434     }
 435     replication_state.component_memory = NULL;
 436     if ( NULL != replication_state.surface_block_array_ptr ){
 437         free(replication_state.surface_block_array_ptr);
 438     }
 439     replication_state.surface_block_array_ptr=NULL;
 440
 441     receiver_socket.close();
 442
 443     receiver_end = true;
 444 }
 445
 446 void    sender_thread(){
 447     l7vs::replication    repli2;
 448
 449     BOOST_CHECK_EQUAL( repli2.get_status(), l7vs::replication::REPLICATION_OUT );
 450     BOOST_CHECK_EQUAL( repli2.initialize(), 0 );
 451     BOOST_CHECK_EQUAL( repli2.get_status(), l7vs::replication::REPLICATION_SLAVE );
 452
 453     unsigned int    size;
 454     void*            ptr;
 455
 456     ptr = repli2.pay_memory( "virtualservice", size );
 457     BOOST_CHECK( NULL != ptr );
 458     BOOST_CHECK_EQUAL( repli2.lock( "virtualservice" ), 0 );
 459     memset( ptr, 'A', size * DATA_SIZE );
 460     repli2.unlock( "virtualservice" );
 461
 462     ptr = repli2.pay_memory( "chash", size );
 463     BOOST_CHECK( NULL != ptr );
 464     BOOST_CHECK_EQUAL( repli2.lock( "chash" ), 0 );
 465     memset( ptr, 'B', size * DATA_SIZE );
 466     repli2.unlock( "chash" );
 467
 468     ptr = repli2.pay_memory( "sslid", size );
 469     BOOST_CHECK( NULL != ptr );
 470     BOOST_CHECK_EQUAL( repli2.lock( "sslid" ), 0 );
 471     memset( ptr, 'C', size * DATA_SIZE );
 472     repli2.unlock( "sslid" );
 473
 474     repli2.switch_to_master();
 475     BOOST_CHECK_EQUAL( repli2.get_status(), l7vs::replication::REPLICATION_MASTER );
 476
 477     sleep(1);
 478
 479     repli2.finalize();
 480 }
 481
 482 void    sender2_thread( const char* target_ip ){
 483 //    boost::asio::ip::udp::endpoint    udp_endpoint( boost::asio::ip::address::from_string( target_ip, 40000 );
 484     boost::asio::ip::udp::endpoint      udp_endpoint( make_endpoint<boost::asio::ip::udp>( target_ip, REPLICATION_PORT ) );
 485 //    boost::asio::ip::udp::socket    sender_socket( global_send_io, udp_endpoint );
 486     boost::asio::ip::udp::socket        sender_socket( global_send_io );
 487
 488     //! Transfer data between active server and standby server.
 489     struct replication_data_struct{
 490         unsigned short                    id;                            //!< ID of Replication Function
 491         char                            pad1[6];
 492         unsigned long long                serial;                        //!< Serial Number
 493         unsigned int                    block_num;                    //!< Block Number in Replication memory
 494         char                            pad2[4];
 495         uint64_t                        size;                        //!< Data size for checking packet loss
 496         char                            data[DATA_SIZE];            //!< Raw data
 497     } replication_data;
 498
 499     size_t send_byte;
 500     boost::system::error_code err;
 501
 502 std::cout << "sender2 " << udp_endpoint.address() << ":" << udp_endpoint.port() << "\n";
 503     memset( &replication_data, 0, sizeof( struct replication_data_struct ) );
 504     // Set replication id
 505     replication_data.id = REPLICATION_ID;
 506     replication_data.block_num = 0;
 507     // set serial
 508     replication_data.serial = 0;
 509
 510     // set data size (sizeof(replication_data))
 511     replication_data.size = sizeof( struct replication_data_struct );
 512
 513     // set replication data (1 block)
 514     memset( replication_data.data, '7', DATA_SIZE );
 515
 516     // send to data
 517 std::cout << "send 1st block\n";
 518     sender_socket.open( udp_endpoint.protocol() );
 519 //    send_byte = sender_socket.send_to( boost::asio::buffer( &replication_data, sizeof( struct replication_data_struct ) ), udp_endpoint );
 520     send_byte = sender_socket.send_to( boost::asio::buffer( &replication_data, sizeof( struct replication_data_struct ) ), udp_endpoint, 0, err );
 521     if ( err ){
 522         std::cout << err.message() << "\n";
 523         sender_socket.close();
 524         return;
 525     }
 526     if ( sizeof( struct replication_data_struct ) != send_byte ){
 527         sender_socket.close();
 528         return;
 529     }
 530     global_send_io.run();
 531     usleep( 10000 );
 532
 533     replication_data.block_num = 1;
 534
 535     // set replication data (1 block)
 536     memset( replication_data.data, '8', DATA_SIZE );
 537
 538     // send to data
 539 std::cout << "send 2nd block\n";
 540 //    send_byte = sender_socket.send_to( boost::asio::buffer( &replication_data, sizeof( struct replication_data_struct ) ), udp_endpoint );
 541     send_byte = sender_socket.send_to( boost::asio::buffer( &replication_data, sizeof( struct replication_data_struct ) ), udp_endpoint, 0, err );
 542     if ( err ){
 543         std::cout << err.message() << "\n";
 544         sender_socket.close();
 545         return;
 546     }
 547     if ( sizeof( struct replication_data_struct ) != send_byte ){
 548         sender_socket.close();
 549         return;
 550     }
 551     global_send_io.run();
 552     usleep( 10000 );
 553
 554     replication_data.block_num = 2;
 555
 556     // set replication data (1 block)
 557     memset( replication_data.data, '9', DATA_SIZE );
 558
 559     // send to data
 560 std::cout << "send 3rd block\n";
 561 //    send_byte = sender_socket.send_to( boost::asio::buffer( &replication_data, sizeof( struct replication_data_struct ) ), udp_endpoint );
 562     send_byte = sender_socket.send_to( boost::asio::buffer( &replication_data, sizeof( struct replication_data_struct ) ), udp_endpoint, 0, err );
 563     if ( err ){
 564         std::cout << err.message() << "\n";
 565         sender_socket.close();
 566         return;
 567     }
 568     if ( sizeof( struct replication_data_struct ) != send_byte ){
 569         sender_socket.close();
 570         return;
 571     }
 572     global_send_io.run();
 573     sleep(1);
 574
 575     sender_socket.close();
 576 }
 577
 578 void lock_thread( l7vs::replication_fake* p_repliX, const char* name ){
 579     std::string    id( name );
 580     p_repliX->lock( id );
 581     locked_end = true;
 582 }
 583
 584
 585
 586
 587
 588
 589 //test case1.
 590 void    replication_initialize_test( int proto ){
 591 //    int    loop;
 592     get_string_stubmode = 0;
 593     get_int_stubmode = 0;
 594     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
 595     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
 596     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
 597     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
 598     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
 599     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
 600     get_int_table[0] = 10000;                        //    "interval"
 601     get_int_table[1] = 64;                            //    "cmponent_size_00"
 602     get_int_table[2] = 1;                            //    "cmponent_size_01"
 603     get_int_table[3] = 200;                            //    "cmponent_size_02"
 604     get_int_table[4] = 10;                            //    "compulsorily_interval"
 605
 606     // unit_test[1]  コンストラクタのテスト
 607     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 608     l7vs::replication    repli1;
 609
 610     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
 611
 612     // unit_test[2]  initializeのテスト(正常系)
 613     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 614     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 615
 616     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 617
 618     // unit_test[3]  finnalizeのテスト(正常系)
 619     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 620     repli1.finalize();
 621
 622     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
 623
 624     // unit_test[4]  initializeのテスト(ip_addrが存在しない)
 625     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 626     get_string_stubmode = 1;
 627     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 628     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 629
 630     // unit_test[5]  initializeのテスト(service_nameが存在しない)
 631     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 632     get_string_stubmode = 2;
 633     repli1.finalize();
 634     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 635     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 636
 637     // unit_test[6]  initializeのテスト(recv_ip_addrが存在しない)
 638     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 639     get_string_stubmode = 3;
 640     repli1.finalize();
 641     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 642     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 643
 644     // unit_test[7]  initializeのテスト(intervalが存在しない)
 645     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 646     get_string_stubmode = 0;
 647     get_int_stubmode = 1;
 648     repli1.finalize();
 649     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 650     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 651
 652     // unit_test[8]  initializeのテスト(全部存在しない initialize自体はOK)
 653     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 654     get_string_stubmode = 1000;
 655     get_int_stubmode = 1000;
 656     repli1.finalize();
 657     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 658     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 659
 660     get_int_stubmode = 0;
 661     // unit_test[9]  initializeのテスト(ip_addrが不正)
 662     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 663     get_string_stubmode = 101;
 664     repli1.finalize();
 665     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 666     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 667
 668     // unit_test[10]  initializeのテスト(service_nameが不正)
 669     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 670     get_string_stubmode = 102;
 671     repli1.finalize();
 672     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 673     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 674
 675     // unit_test[11]  initializeのテスト(recv_ip_addrが不正)
 676     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 677     get_string_stubmode = 103;
 678     repli1.finalize();
 679     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 680     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 681
 682     // unit_test[12]  initializeのテスト(intervalが不正)
 683     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 684     get_string_stubmode = 0;
 685     get_int_stubmode = 101;
 686     repli1.finalize();
 687     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 688     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 689
 690     get_int_stubmode = 0;
 691     // unit_test[13]  check_parameterのテスト(cmponent_id_00が存在しない)
 692     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 693     get_string_stubmode = 4;
 694     repli1.finalize();
 695     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 696     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 697
 698     // unit_test[14]  initializeのテスト(cmponent_id_00が不正)
 699     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 700     get_string_stubmode = 104;
 701     repli1.finalize();
 702     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 703     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 704
 705     get_string_stubmode = 0;
 706     // unit_test[15]  initializeのテスト(cmponent_size_00が存在しない)
 707     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 708     get_int_stubmode = 2;
 709     repli1.finalize();
 710     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 711     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 712
 713     // unit_test[16]  initializeのテスト(cmponent_size_00が不正)
 714     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 715     get_int_stubmode = 102;
 716     repli1.finalize();
 717     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 718     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 719
 720     get_int_stubmode = 0;
 721     // unit_test[17]  initializeのテスト(cmponent_id_01が存在しない OK)
 722     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 723     get_string_stubmode = 5;
 724     repli1.finalize();
 725     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 726     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 727
 728     // unit_test[18]  initializeのテスト(cmponent_id_01が不正)
 729     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 730     get_string_stubmode = 105;
 731     repli1.finalize();
 732     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 733     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 734
 735     get_string_stubmode = 0;
 736     // unit_test[19]  initializeのテスト(cmponent_size_01が存在しない OK)
 737     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 738     get_int_stubmode = 3;
 739     repli1.finalize();
 740     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 741     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 742
 743     // unit_test[20]  initializeのテスト(cmponent_size_01が不正)
 744     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 745     get_int_stubmode = 103;
 746     repli1.finalize();
 747     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 748     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 749
 750     get_int_stubmode = 0;
 751     // unit_test[21]  initializeのテスト(cmponent_id_02が存在しない OK)
 752     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 753     get_string_stubmode = 6;
 754     repli1.finalize();
 755     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 756     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 757
 758     // unit_test[22]  initializeのテスト(cmponent_id_02が不正)
 759     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 760     get_string_stubmode = 106;
 761     repli1.finalize();
 762     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 763     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 764
 765     get_string_stubmode = 0;
 766     // unit_test[23]  initializeのテスト(cmponent_size_02が存在しない OK)
 767     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 768     get_int_stubmode = 4;
 769     repli1.finalize();
 770     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 771     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 772
 773     // unit_test[24]  initializeのテスト(cmponent_size_02が不正)
 774     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 775     get_int_stubmode = 104;
 776     repli1.finalize();
 777     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 778     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 779
 780     // unit_test[25]  initializeのテスト(total_blockが0)
 781     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 782     get_int_stubmode = 102;
 783     get_string_stubmode = 5;
 784     repli1.finalize();
 785     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 786     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 787
 788     get_int_stubmode = 0;
 789     get_string_stubmode = 0;
 790     // unit_test[26]  check_parameterのテスト(intervalが上限以上)
 791     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 792     get_int_table[0] = 10001;                        //    "interval"
 793     repli1.finalize();
 794     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 795     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 796
 797     // unit_test[27]  check_parameterのテスト(intervalが下限未満)
 798     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 799     get_int_table[0] = 9;                            //    "interval"
 800     repli1.finalize();
 801     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 802     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 803
 804     get_int_table[0] = 10000;                        //    "interval"
 805     // unit_test[28]  check_parameterのテスト(component_idが重複)
 806     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 807     strcpy( get_string_table[4], "virtualservice" );            //    "cmponent_id_01"
 808     strcpy( get_string_table[5], "virtualservice" );            //    "cmponent_id_02"
 809     repli1.finalize();
 810     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 811     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 812
 813     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
 814     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
 815
 816     // unit_test[29]  check_parameterのテスト(total_blockが上限以上)
 817     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 818     get_int_table[1] = 33334;                        //    "cmponent_size_00"
 819     get_int_table[2] = 33334;                        //    "cmponent_size_01"
 820     get_int_table[3] = 33334;                        //    "cmponent_size_02"
 821     repli1.finalize();
 822     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 823     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 824
 825     get_int_table[1] = 64;                            //    "cmponent_size_00"
 826     get_int_table[2] = 1;                            //    "cmponent_size_01"
 827     get_int_table[3] = 200;                            //    "cmponent_size_02"
 828
 829     // unit_test[30]  getrplのテスト(Replication memoryのmalloc失敗)
 830     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 831     repli1.finalize();
 832     malloc_count = 0 ;
 833     malloc_dbg_install();
 834     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 835     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 836     malloc_dbg_uninstall();
 837
 838     // unit_test[31]  getcmpのテスト(Components memoryのmalloc失敗)
 839     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 840     repli1.finalize();
 841     malloc_count = 1 ;
 842     malloc_dbg_install();
 843     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 844     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 845     malloc_dbg_uninstall();
 846
 847     // unit_test[32]  getsrfのテスト(surface_blockのmalloc失敗)
 848     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 849     repli1.finalize();
 850     malloc_count = 2 ;
 851     malloc_dbg_install();
 852     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 853     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 854     malloc_dbg_uninstall();
 855
 856     // unit_test[33]  initializeのテスト(initialize済み)
 857     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 858     repli1.finalize();
 859     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 860     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 861     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 862
 863     // unit_test[34]  finalizeのテスト(finalize済み)
 864     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 865     repli1.finalize();
 866     repli1.finalize();
 867     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
 868 }
 869
 870 //test case2.
 871 void    replication_switch_to_master_test( int proto ){
 872     get_string_stubmode = 0;
 873     get_int_stubmode = 0;
 874     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
 875     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
 876     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
 877     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
 878     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
 879     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
 880     get_int_table[0] = 10000;                        //    "interval"
 881     get_int_table[1] = 64;                            //    "cmponent_size_00"
 882     get_int_table[2] = 1;                            //    "cmponent_size_01"
 883     get_int_table[3] = 200;                            //    "cmponent_size_02"
 884     get_int_table[4] = 10;                            //    "compulsorily_interval"
 885
 886     l7vs::replication    repli1;
 887
 888     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
 889     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 890     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 891
 892     // unit_test[35]  switch_to_master&set_masterのテスト(SLAVE時)
 893     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 894     repli1.switch_to_master();
 895     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
 896
 897     // unit_test[36]  switch_to_masterのテスト(MASTER時)
 898     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 899     repli1.switch_to_master();
 900     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
 901
 902     // unit_test[37]  switch_to_masterのテスト(MASTER_STOP時)
 903     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 904     repli1.stop();
 905     repli1.switch_to_master();
 906     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
 907
 908     // unit_test[38]  switch_to_masterのテスト(未初期化)
 909     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 910     repli1.finalize();
 911     repli1.switch_to_master();
 912     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
 913
 914     // unit_test[39]  switch_to_master&set_masterのテスト(SLAVE_STOP)
 915     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 916     repli1.finalize();
 917     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 918     repli1.stop();
 919     repli1.switch_to_master();
 920     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
 921
 922     // unit_test[40]  switch_to_masterのテスト(SINGLE時)
 923     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 924     get_string_stubmode = 1;
 925     get_int_stubmode = 1;
 926     repli1.finalize();
 927     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 928     repli1.switch_to_master();
 929     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
 930
 931     repli1.finalize();
 932     get_string_stubmode = 0;
 933     get_int_stubmode = 0;
 934 }
 935
 936 //test case3.
 937 void    replication_switch_to_slave_test( int proto ){
 938     get_string_stubmode = 0;
 939     get_int_stubmode = 0;
 940     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
 941     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
 942     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
 943     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
 944     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
 945     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
 946     get_int_table[0] = 10000;                        //    "interval"
 947     get_int_table[1] = 64;                            //    "cmponent_size_00"
 948     get_int_table[2] = 1;                            //    "cmponent_size_01"
 949     get_int_table[3] = 200;                            //    "cmponent_size_02"
 950     get_int_table[4] = 10;                            //    "compulsorily_interval"
 951
 952     l7vs::replication    repli1;
 953
 954     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
 955     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 956     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 957
 958     // unit_test[41]  switch_to_slaveのテスト(SLAVE時)
 959     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 960     repli1.switch_to_slave();
 961     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 962
 963     // unit_test[42]  switch_to_slave&set_slaveのテスト(MASTER時)
 964     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 965     repli1.switch_to_master();
 966     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
 967     repli1.switch_to_slave();
 968     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
 969
 970     // unit_test[43]  switch_to_slave&set_slaveのテスト(MASTER_STOP時)
 971     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 972     repli1.switch_to_master();
 973     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
 974     repli1.stop();
 975     repli1.switch_to_slave();
 976     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
 977
 978     // unit_test[44]  switch_to_slaveのテスト(未初期化)
 979     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 980     repli1.finalize();
 981     repli1.switch_to_slave();
 982     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
 983
 984     // unit_test[45]  switch_to_slaveのテスト(SLAVE_STOP)
 985     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 986     repli1.finalize();
 987     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
 988     repli1.stop();
 989     repli1.switch_to_slave();
 990     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
 991
 992     // unit_test[46]  switch_to_slaveのテスト(SINGLE時)
 993     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
 994     get_string_stubmode = 1;
 995     get_int_stubmode = 1;
 996     repli1.finalize();
 997     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
 998     repli1.switch_to_slave();
 999     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
1000
1001     repli1.finalize();
1002     get_string_stubmode = 0;
1003     get_int_stubmode = 0;
1004 }
1005
1006 //test case4.
1007 void    replication_pay_memory_test( int proto ){
1008     unsigned int    size;
1009     void*            ptr;
1010
1011     get_string_stubmode = 0;
1012     get_int_stubmode = 0;
1013     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1014     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1015     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1016     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1017     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1018     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1019     get_int_table[0] = 10000;                        //    "interval"
1020     get_int_table[1] = 64;                            //    "cmponent_size_00"
1021     get_int_table[2] = 1;                            //    "cmponent_size_01"
1022     get_int_table[3] = 200;                            //    "cmponent_size_02"
1023     get_int_table[4] = 10;                            //    "compulsorily_interval"
1024
1025     l7vs::replication    repli1;
1026
1027     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1028     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1029     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1030
1031     // unit_test[47]  pay_memoryのテスト(SLAVE virtualservice時)
1032     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1033     ptr = repli1.pay_memory( "virtualservice", size );
1034     BOOST_CHECK( NULL != ptr );
1035     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[1] );
1036
1037     // unit_test[48]  pay_memoryのテスト(SLAVE chash時)
1038     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1039     ptr = repli1.pay_memory( "chash", size );
1040     BOOST_CHECK( NULL != ptr );
1041     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[2] );
1042
1043     // unit_test[49]  pay_memoryのテスト(SLAVE sslid時)
1044     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1045     ptr = repli1.pay_memory( "sslid", size );
1046     BOOST_CHECK( NULL != ptr );
1047     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[3] );
1048
1049     // unit_test[50]  pay_memoryのテスト(virtualservice時 サイズ0)
1050     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1051     get_int_table[1] = 0;                            //    "cmponent_size_00"
1052     repli1.finalize();
1053     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1054     ptr = repli1.pay_memory( "virtualservice", size );
1055     BOOST_CHECK( NULL == ptr );
1056     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[1] );
1057
1058     get_int_table[1] = 64;                            //    "cmponent_size_00"
1059
1060     // unit_test[51]  pay_memoryのテスト(chash時 サイズ0)
1061     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1062     get_int_table[2] = 0;                            //    "cmponent_size_01"
1063     repli1.finalize();
1064     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1065     ptr = repli1.pay_memory( "chash", size );
1066     BOOST_CHECK( NULL == ptr );
1067     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[2] );
1068
1069     get_int_table[2] = 1;                            //    "cmponent_size_01"
1070
1071     // unit_test[52]  pay_memoryのテスト(sslid時 サイズ0)
1072     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1073     get_int_table[3] = 0;                            //    "cmponent_size_02"
1074     repli1.finalize();
1075     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1076     ptr = repli1.pay_memory( "sslid", size );
1077     BOOST_CHECK( NULL == ptr );
1078     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[3] );
1079
1080     get_int_table[3] = 200;                            //    "cmponent_size_02"
1081
1082     // unit_test[53]  pay_memoryのテスト(id無効)
1083     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1084     repli1.finalize();
1085     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1086     ptr = repli1.pay_memory( "unknown", size );
1087     BOOST_CHECK( NULL == ptr );
1088     BOOST_CHECK_EQUAL( size, 0U );
1089
1090     // unit_test[54]  pay_memoryのテスト(SLAVE_STOP virtualservice時)
1091     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1092     repli1.stop();
1093     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
1094     ptr = repli1.pay_memory( "virtualservice", size );
1095     BOOST_CHECK( NULL != ptr );
1096     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[1] );
1097
1098     // unit_test[55]  pay_memoryのテスト(SLAVE_STOP chash時)
1099     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1100     ptr = repli1.pay_memory( "chash", size );
1101     BOOST_CHECK( NULL != ptr );
1102     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[2] );
1103
1104     // unit_test[56]  pay_memoryのテスト(SLAVE_STOP sslid時)
1105     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1106     ptr = repli1.pay_memory( "sslid", size );
1107     BOOST_CHECK( NULL != ptr );
1108     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[3] );
1109
1110     // unit_test[57]  pay_memoryのテスト(MASTER_STOP virtualservice時)
1111     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1112     repli1.switch_to_master();
1113     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
1114     ptr = repli1.pay_memory( "virtualservice", size );
1115     BOOST_CHECK( NULL != ptr );
1116     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[1] );
1117
1118     // unit_test[58]  pay_memoryのテスト(MASTER_STOP chash時)
1119     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1120     ptr = repli1.pay_memory( "chash", size );
1121     BOOST_CHECK( NULL != ptr );
1122     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[2] );
1123
1124     // unit_test[59]  pay_memoryのテスト(MASTER_STOP sslid時)
1125     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1126     ptr = repli1.pay_memory( "sslid", size );
1127     BOOST_CHECK( NULL != ptr );
1128     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[3] );
1129
1130     // unit_test[60]  pay_memoryのテスト(MASTER virtualservice時)
1131     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1132     repli1.start();
1133     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1134     ptr = repli1.pay_memory( "virtualservice", size );
1135     BOOST_CHECK( NULL != ptr );
1136     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[1] );
1137
1138     // unit_test[61]  pay_memoryのテスト(MASTER chash時)
1139     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1140     ptr = repli1.pay_memory( "chash", size );
1141     BOOST_CHECK( NULL != ptr );
1142     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[2] );
1143
1144     // unit_test[62]  pay_memoryのテスト(MASTER sslid時)
1145     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1146     ptr = repli1.pay_memory( "sslid", size );
1147     BOOST_CHECK( NULL != ptr );
1148     BOOST_CHECK_EQUAL( size, ( unsigned int )get_int_table[3] );
1149
1150     // unit_test[63]  pay_memoryのテスト(未初期化 virtualservice時)
1151     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1152     repli1.finalize();
1153     ptr = repli1.pay_memory( "virtualservice", size );
1154     BOOST_CHECK( NULL == ptr );
1155     BOOST_CHECK_EQUAL( size, 0U );
1156
1157     // unit_test[64]  pay_memoryのテスト(未初期化 chash時)
1158     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1159     ptr = repli1.pay_memory( "chash", size );
1160     BOOST_CHECK( NULL == ptr );
1161     BOOST_CHECK_EQUAL( size, 0U );
1162
1163     // unit_test[65]  pay_memoryのテスト(未初期化 sslid時)
1164     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1165     ptr = repli1.pay_memory( "sslid", size );
1166     BOOST_CHECK( NULL == ptr );
1167     BOOST_CHECK_EQUAL( size, 0U );
1168
1169     // unit_test[66]  pay_memoryのテスト(SINGLE virtualservice時)
1170     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1171     get_string_stubmode = 1;
1172     get_int_stubmode = 1;
1173     repli1.finalize();
1174     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
1175     ptr = repli1.pay_memory( "virtualservice", size );
1176     BOOST_CHECK( NULL == ptr );
1177     BOOST_CHECK_EQUAL( size, 0U );
1178
1179     // unit_test[67]  pay_memoryのテスト(SINGLE chash時)
1180     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1181     ptr = repli1.pay_memory( "chash", size );
1182     BOOST_CHECK( NULL == ptr );
1183     BOOST_CHECK_EQUAL( size, 0U );
1184
1185     // unit_test[68]  pay_memoryのテスト(SINGLE sslid時)
1186     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1187     ptr = repli1.pay_memory( "sslid", size );
1188     BOOST_CHECK( NULL == ptr );
1189     BOOST_CHECK_EQUAL( size, 0U );
1190
1191     repli1.finalize();
1192     get_string_stubmode = 0;
1193     get_int_stubmode = 0;
1194 }
1195
1196 //test case5.
1197 void    replication_dump_memory_test( int proto ){
1198     get_string_stubmode = 0;
1199     get_int_stubmode = 0;
1200     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1201     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1202     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1203     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1204     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1205     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1206     get_int_table[0] = 10000;                        //    "interval"
1207     get_int_table[1] = 64;                            //    "cmponent_size_00"
1208     get_int_table[2] = 1;                            //    "cmponent_size_01"
1209     get_int_table[3] = 200;                            //    "cmponent_size_02"
1210     get_int_table[4] = 10;                            //    "compulsorily_interval"
1211
1212     l7vs::replication    repli1;
1213
1214     get_int_table[1] = 1;                            //    "cmponent_size_00"
1215     get_int_table[2] = 1;                            //    "cmponent_size_01"
1216     get_int_table[3] = 1;                            //    "cmponent_size_02"
1217
1218     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1219     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1220     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1221
1222     // unit_test[69]  dump_memoryのテスト(SLAVE時)
1223     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1224     repli1.dump_memory();
1225     BOOST_CHECK( 1 );
1226
1227     // unit_test[70]  dump_memoryのテスト(SLAVE_STOP時)
1228     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1229     repli1.stop();
1230     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
1231     repli1.dump_memory();
1232     BOOST_CHECK( 1 );
1233
1234     // unit_test[71]  dump_memoryのテスト(MASTER_STOP時)
1235     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1236     repli1.switch_to_master();
1237     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
1238     repli1.dump_memory();
1239     BOOST_CHECK( 1 );
1240
1241     // unit_test[72]  dump_memoryのテスト(MASTER時)
1242     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1243     repli1.start();
1244     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1245     repli1.dump_memory();
1246     BOOST_CHECK( 1 );
1247
1248     // unit_test[73]  dump_memoryのテスト(未初期化)
1249     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1250     repli1.finalize();
1251     repli1.dump_memory();
1252     BOOST_CHECK( 1 );
1253
1254     // unit_test[74]  dump_memoryのテスト(SINGLE時)
1255     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1256     get_string_stubmode = 1;
1257     get_int_stubmode = 1;
1258     repli1.finalize();
1259     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
1260     repli1.dump_memory();
1261     BOOST_CHECK( 1 );
1262
1263     repli1.finalize();
1264     get_string_stubmode = 0;
1265     get_int_stubmode = 0;
1266 }
1267
1268 //test case6.
1269 void    replication_start_test( int proto ){
1270     get_string_stubmode = 0;
1271     get_int_stubmode = 0;
1272     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1273     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1274     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1275     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1276     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1277     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1278     get_int_table[0] = 10000;                        //    "interval"
1279     get_int_table[1] = 64;                            //    "cmponent_size_00"
1280     get_int_table[2] = 1;                            //    "cmponent_size_01"
1281     get_int_table[3] = 200;                            //    "cmponent_size_02"
1282     get_int_table[4] = 10;                            //    "compulsorily_interval"
1283
1284     l7vs::replication    repli1;
1285
1286     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1287     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1288     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1289
1290     // unit_test[75]  startのテスト(SLAVE時)
1291     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1292     repli1.start();
1293     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1294
1295     // unit_test[76]  startのテスト(SLAVE_STOP時)
1296     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1297     repli1.stop();
1298     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
1299     repli1.start();
1300     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1301
1302     // unit_test[77]  startのテスト(MASTER時)
1303     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1304     repli1.switch_to_master();
1305     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1306     repli1.start();
1307     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1308
1309     // unit_test[78]  startのテスト(MASTER_STOP時)
1310     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1311     repli1.stop();
1312     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
1313     repli1.start();
1314     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1315
1316     // unit_test[79]  startのテスト(未初期化)
1317     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1318     repli1.finalize();
1319     repli1.start();
1320     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1321
1322     // unit_test[80]  startのテスト(SINGLE時)
1323     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1324     get_string_stubmode = 1;
1325     get_int_stubmode = 1;
1326     repli1.finalize();
1327     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
1328     repli1.start();
1329     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
1330
1331     repli1.finalize();
1332     get_string_stubmode = 0;
1333     get_int_stubmode = 0;
1334 }
1335
1336 //test case7.
1337 void    replication_stop_test( int proto ){
1338     get_string_stubmode = 0;
1339     get_int_stubmode = 0;
1340     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1341     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1342     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1343     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1344     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1345     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1346     get_int_table[0] = 10000;                        //    "interval"
1347     get_int_table[1] = 64;                            //    "cmponent_size_00"
1348     get_int_table[2] = 1;                            //    "cmponent_size_01"
1349     get_int_table[3] = 200;                            //    "cmponent_size_02"
1350     get_int_table[4] = 10;                            //    "compulsorily_interval"
1351
1352     l7vs::replication    repli1;
1353
1354     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1355     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1356     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1357
1358     // unit_test[81]  stopのテスト(SLAVE時)
1359     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1360     repli1.stop();
1361     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
1362
1363     // unit_test[82]  stopのテスト(SLAVE_STOP時)
1364     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1365     repli1.stop();
1366     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
1367
1368     // unit_test[83]  stopのテスト(MASTER_STOP時)
1369     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1370     repli1.switch_to_master();
1371     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
1372     repli1.stop();
1373     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
1374
1375     // unit_test[84]  stopのテスト(MASTER時)
1376     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1377     repli1.start();
1378     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1379     repli1.stop();
1380     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
1381
1382     // unit_test[85]  stopのテスト(未初期化)
1383     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1384     repli1.finalize();
1385     repli1.stop();
1386     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1387
1388     // unit_test[86]  stopのテスト(SINGLE時)
1389     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1390     get_string_stubmode = 1;
1391     get_int_stubmode = 1;
1392     repli1.finalize();
1393     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
1394     repli1.stop();
1395     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
1396
1397     repli1.finalize();
1398     get_string_stubmode = 0;
1399     get_int_stubmode = 0;
1400 }
1401
1402 //test case8.
1403 void    replication_force_replicate_test( int proto ){
1404     get_string_stubmode = 0;
1405     get_int_stubmode = 0;
1406     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1407     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1408     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1409     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1410     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1411     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1412     get_int_table[0] = 10000;                        //    "interval"
1413     get_int_table[1] = 64;                            //    "cmponent_size_00"
1414     get_int_table[2] = 1;                            //    "cmponent_size_01"
1415     get_int_table[3] = 200;                            //    "cmponent_size_02"
1416     get_int_table[4] = 10;                            //    "compulsorily_interval"
1417
1418     l7vs::replication_fake    repli1;
1419
1420     get_int_table[1] = 1;                            //    "cmponent_size_00"
1421     get_int_table[2] = 1;                            //    "cmponent_size_01"
1422     get_int_table[3] = 1;                            //    "cmponent_size_02"
1423
1424     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1425     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1426     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1427
1428     // unit_test[87]  force_replicateのテスト(SLAVE時)
1429     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1430     repli1.force_replicate();
1431     BOOST_CHECK( 1 );
1432
1433     // unit_test[88]  force_replicateのテスト(SLAVE_STOP時)
1434     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1435     repli1.stop();
1436     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
1437     repli1.force_replicate();
1438     BOOST_CHECK( 1 );
1439
1440     // unit_test[89]  force_replicateのテスト(MASTER_STOP時)
1441     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1442     repli1.switch_to_master();
1443     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
1444     repli1.force_replicate();
1445     BOOST_CHECK( 1 );
1446
1447     // unit_test[90]  force_replicateのテスト(MASTER時 "compulsorily_interval"が存在しない)
1448     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1449     get_int_stubmode = 5;
1450     repli1.start();
1451     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1452     repli1.force_replicate();
1453     BOOST_CHECK( 1 );
1454
1455     // unit_test[91]  force_replicateのテスト(MASTER時 "compulsorily_interval"が上限以上)
1456     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1457     get_int_table[4] = 401;
1458     repli1.force_replicate();
1459     BOOST_CHECK( 1 );
1460
1461     // unit_test[92]  force_replicateのテスト(MASTER時 "compulsorily_interval"が下限未満)
1462     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1463     get_int_table[4] = 3;
1464     repli1.force_replicate();
1465     BOOST_CHECK( 1 );
1466
1467     get_int_table[4] = 10;
1468
1469     // unit_test[93]  force_replicateのテスト(未初期化)
1470     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1471     repli1.finalize();
1472     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1473     repli1.force_replicate();
1474     BOOST_CHECK( 1 );
1475
1476     // unit_test[94]  force_replicateのテスト(SINGLE時)
1477     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1478     get_string_stubmode = 1;
1479     get_int_stubmode = 1;
1480     repli1.finalize();
1481     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
1482     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
1483     repli1.force_replicate();
1484     BOOST_CHECK( 1 );
1485
1486     repli1.finalize();
1487     get_string_stubmode = 0;
1488     get_int_stubmode = 0;
1489
1490     // unit_test[95]  force_replicate&handle_sendのテスト(MASTER時)
1491     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1492
1493     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1494     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1495     repli1.disable_send_thread();
1496
1497     unsigned int    size;
1498     void*            ptr;
1499
1500     ptr = repli1.pay_memory( "virtualservice", size );
1501     BOOST_CHECK( NULL != ptr );
1502     BOOST_CHECK_EQUAL( repli1.lock( "virtualservice" ), 0 );
1503     memset( ptr, '1', size * DATA_SIZE );
1504     repli1.unlock( "virtualservice" );
1505
1506     ptr = repli1.pay_memory( "chash", size );
1507     BOOST_CHECK( NULL != ptr );
1508     BOOST_CHECK_EQUAL( repli1.lock( "chash" ), 0 );
1509     memset( ptr, '2', size * DATA_SIZE );
1510     repli1.unlock( "chash" );
1511
1512     ptr = repli1.pay_memory( "sslid", size );
1513     BOOST_CHECK( NULL != ptr );
1514     BOOST_CHECK_EQUAL( repli1.lock( "sslid" ), 0 );
1515     memset( ptr, '3', size * DATA_SIZE );
1516     repli1.unlock( "sslid" );
1517
1518     repli1.switch_to_master();
1519     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1520
1521     receiver_end = false;
1522     boost::thread    thread_item1( boost::bind ( &receiver_thread, recv_ip_table[proto] ) );
1523
1524     repli1.force_replicate();
1525
1526     repli1.finalize();
1527
1528     while( !receiver_end ){
1529         global_receive_io.poll();
1530     }
1531
1532     thread_item1.join();
1533
1534     BOOST_CHECK( 1 );
1535 }
1536
1537 //test case9.
1538 void    replication_reset_test( int proto ){
1539     get_string_stubmode = 0;
1540     get_int_stubmode = 0;
1541     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1542     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1543     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1544     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1545     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1546     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1547     get_int_table[0] = 10000;                        //    "interval"
1548     get_int_table[1] = 64;                            //    "cmponent_size_00"
1549     get_int_table[2] = 1;                            //    "cmponent_size_01"
1550     get_int_table[3] = 200;                            //    "cmponent_size_02"
1551     get_int_table[4] = 10;                            //    "compulsorily_interval"
1552
1553     l7vs::replication    repli1;
1554
1555     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1556     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1557     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1558
1559     // unit_test[96]  resetのテスト(SLAVE時)
1560     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1561     repli1.reset();
1562     BOOST_CHECK( 1 );
1563
1564     // unit_test[97]  resetのテスト(SLAVE_STOP時)
1565     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1566     repli1.stop();
1567     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
1568     repli1.reset();
1569     BOOST_CHECK( 1 );
1570
1571     // unit_test[98]  resetのテスト(MASTER_STOP時)
1572     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1573     repli1.switch_to_master();
1574     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
1575     repli1.reset();
1576     BOOST_CHECK( 1 );
1577
1578     // unit_test[99]  resetのテスト(MASTER時)
1579     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1580     repli1.start();
1581     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1582     repli1.reset();
1583     BOOST_CHECK( 1 );
1584
1585     // unit_test[100]  resetのテスト(未初期化)
1586     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1587     repli1.finalize();
1588     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1589     repli1.reset();
1590     BOOST_CHECK( 1 );
1591
1592     // unit_test[101]  resetのテスト(SINGLE時)
1593     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1594     get_string_stubmode = 1;
1595     get_int_stubmode = 1;
1596     repli1.finalize();
1597     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
1598     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
1599     repli1.reset();
1600     BOOST_CHECK( 1 );
1601
1602     get_string_stubmode = 0;
1603     get_int_stubmode = 0;
1604
1605     repli1.finalize();
1606     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1607     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1608
1609     // unit_test[102]  resetのテスト(intervalが存在しない)
1610     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1611     get_int_stubmode = 1;
1612     repli1.reset();
1613     BOOST_CHECK( 1 );
1614
1615     // unit_test[103]  resetのテスト(intervalが不正)
1616     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1617     get_int_stubmode = 101;
1618     repli1.reset();
1619     BOOST_CHECK( 1 );
1620
1621     get_int_stubmode = 0;
1622     // unit_test[104]  resetのテスト(intervalが上限以上)
1623     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1624     get_int_table[0] = 10001;                        //    "interval"
1625     repli1.reset();
1626     BOOST_CHECK( 1 );
1627
1628     // unit_test[105]  resetのテスト(intervalが下限未満)
1629     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1630     get_int_table[0] = 9;                            //    "interval"
1631     repli1.reset();
1632     BOOST_CHECK( 1 );
1633
1634     get_int_table[0] = 10000;                        //    "interval"
1635     repli1.finalize();
1636 }
1637
1638 //test case10.
1639 void    replication_get_status_test( int proto ){
1640     get_string_stubmode = 0;
1641     get_int_stubmode = 0;
1642     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1643     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1644     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1645     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1646     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1647     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1648     get_int_table[0] = 10000;                        //    "interval"
1649     get_int_table[1] = 64;                            //    "cmponent_size_00"
1650     get_int_table[2] = 1;                            //    "cmponent_size_01"
1651     get_int_table[3] = 200;                            //    "cmponent_size_02"
1652     get_int_table[4] = 10;                            //    "compulsorily_interval"
1653
1654     l7vs::replication    repli1;
1655
1656     // unit_test[106]  get_statusのテスト(未初期化)
1657     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1658     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1659
1660     // unit_test[107]  get_statusのテスト(SLAVE時)
1661     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1662     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1663     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1664
1665     // unit_test[108]  get_statusのテスト(MASTER時)
1666     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1667     repli1.switch_to_master();
1668     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
1669
1670     // unit_test[109]  get_statusのテスト(MASTER_STOP時)
1671     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1672     repli1.stop();
1673     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
1674
1675     // unit_test[110]  get_statusのテスト(SLAVE_STOP)
1676     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1677     repli1.switch_to_slave();
1678     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
1679
1680     // unit_test[111]  get_statusのテスト(SINGLE時)
1681     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1682     get_string_stubmode = 1;
1683     get_int_stubmode = 1;
1684     repli1.finalize();
1685     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
1686     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
1687
1688     repli1.finalize();
1689     get_string_stubmode = 0;
1690     get_int_stubmode = 0;
1691 }
1692
1693 //test case11.
1694 void    replication_lock_test( int proto ){
1695     get_string_stubmode = 0;
1696     get_int_stubmode = 0;
1697     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1698     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1699     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1700     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1701     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1702     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1703     get_int_table[0] = 10000;                        //    "interval"
1704     get_int_table[1] = 64;                            //    "cmponent_size_00"
1705     get_int_table[2] = 1;                            //    "cmponent_size_01"
1706     get_int_table[3] = 200;                            //    "cmponent_size_02"
1707     get_int_table[4] = 10;                            //    "compulsorily_interval"
1708
1709     l7vs::replication_fake    repli1;
1710
1711     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1712     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1713     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1714
1715     // unit_test[112]  lockのテスト(初期状態)
1716     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1717     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1718     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1719     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1720
1721     // unit_test[113]  lockのテスト("virtualservice")
1722     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1723     BOOST_CHECK_EQUAL( repli1.lock( "virtualservice" ), 0 );
1724     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1725     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1726     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1727
1728     // unit_test[114]  lockのテスト(再度"virtualservice")
1729     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1730 //    BOOST_CHECK_EQUAL( repli1.lock( "virtualservice" ), 0 );        // 一度帰ってこなくなるのを確認したらオミット
1731     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1732     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1733     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1734
1735     // unit_test[115]  lockのテスト("chash")
1736     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1737     BOOST_CHECK_EQUAL( repli1.lock( "chash" ), 0 );
1738     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1739     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1740     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1741
1742     // unit_test[116]  lockのテスト(再度"chash")
1743     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1744 //    BOOST_CHECK_EQUAL( repli1.lock( "chash" ), 0 );                    // 一度帰ってこなくなるのを確認したらオミット
1745     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1746     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1747     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1748
1749     // unit_test[117]  lockのテスト("sslid")
1750     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1751     BOOST_CHECK_EQUAL( repli1.lock( "sslid" ), 0 );
1752     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1753     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1754     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1755
1756     // unit_test[118]  lockのテスト(再度"sslid")
1757     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1758 //    BOOST_CHECK_EQUAL( repli1.lock( "sslid" ), 0 );                    // 一度帰ってこなくなるのを確認したらオミット
1759     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1760     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1761     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1762
1763     // unit_test[119]  lockのテスト(不正なid)
1764     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1765     BOOST_CHECK_EQUAL( repli1.lock( "unknown" ), -1 );
1766
1767     // unit_test[120]  lockのテスト(他スレッド "virtualservice")
1768     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1769     locked_end = false;
1770     boost::thread    thread_item1( boost::bind ( &lock_thread, &repli1, "virtualservice" ) );
1771     BOOST_CHECK_EQUAL( locked_end, false );
1772     repli1.unlock( "virtualservice" );
1773
1774     thread_item1.join();
1775
1776     BOOST_CHECK_EQUAL( locked_end, true );
1777     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1778
1779     // unit_test[121]  lockのテスト(他スレッド "sslid")
1780     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1781     locked_end = false;
1782     boost::thread    thread_item2( boost::bind ( &lock_thread, &repli1, "chash" ) );
1783     BOOST_CHECK_EQUAL( locked_end, false );
1784     repli1.unlock( "chash" );
1785
1786     thread_item2.join();
1787
1788     BOOST_CHECK_EQUAL( locked_end, true );
1789     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1790
1791     // unit_test[122]  lockのテスト(他スレッド "sslid")
1792     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1793     locked_end = false;
1794     boost::thread    thread_item3( boost::bind ( &lock_thread, &repli1, "sslid" ) );
1795     BOOST_CHECK_EQUAL( locked_end, false );
1796     repli1.unlock( "sslid" );
1797
1798     thread_item3.join();
1799
1800     BOOST_CHECK_EQUAL( locked_end, true );
1801     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1802
1803
1804     repli1.unlock( "virtualservice" );
1805     repli1.unlock( "chash" );
1806     repli1.unlock( "sslid" );
1807
1808     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1809     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1810     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1811
1812     repli1.finalize();
1813 }
1814
1815 //test case12.
1816 void    replication_unlock_test( int proto ){
1817     get_string_stubmode = 0;
1818     get_int_stubmode = 0;
1819     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1820     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1821     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1822     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1823     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1824     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1825     get_int_table[0] = 10000;                        //    "interval"
1826     get_int_table[1] = 64;                            //    "cmponent_size_00"
1827     get_int_table[2] = 1;                            //    "cmponent_size_01"
1828     get_int_table[3] = 200;                            //    "cmponent_size_02"
1829     get_int_table[4] = 10;                            //    "compulsorily_interval"
1830
1831     l7vs::replication_fake    repli1;
1832
1833     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1834     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1835     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1836
1837     // unit_test[123]  unlockのテスト(lock済み状態)
1838     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1839     BOOST_CHECK_EQUAL( repli1.lock( "virtualservice" ), 0 );
1840     BOOST_CHECK_EQUAL( repli1.lock( "chash" ), 0 );
1841     BOOST_CHECK_EQUAL( repli1.lock( "sslid" ), 0 );
1842     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1843     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1844     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1845
1846     // unit_test[124]  unlockのテスト("virtualservice")
1847     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1848     BOOST_CHECK_EQUAL( repli1.unlock( "virtualservice" ), 0 );
1849     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1850     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1851     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1852
1853     // unit_test[125]  unlockのテスト(再度"virtualservice")
1854     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1855     BOOST_CHECK_EQUAL( repli1.unlock( "virtualservice" ), 0 );
1856     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1857     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1858     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1859
1860     // unit_test[126]  unlockのテスト("chash")
1861     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1862     BOOST_CHECK_EQUAL( repli1.unlock( "chash" ), 0 );
1863     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1864     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1865     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1866
1867     // unit_test[127]  unlockのテスト(再度"chash")
1868     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1869     BOOST_CHECK_EQUAL( repli1.unlock( "chash" ), 0 );
1870     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1871     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1872     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1873
1874     // unit_test[128]  unlockのテスト("sslid")
1875     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1876     BOOST_CHECK_EQUAL( repli1.unlock( "sslid" ), 0 );
1877     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1878     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1879     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1880
1881     // unit_test[129]  unlockのテスト(再度"sslid")
1882     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1883     BOOST_CHECK_EQUAL( repli1.unlock( "sslid" ), 0 );
1884     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1885     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1886     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1887
1888     // unit_test[130]  unlockのテスト(不正なid)
1889     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1890     BOOST_CHECK_EQUAL( repli1.unlock( "unknown" ), -1 );
1891
1892     repli1.finalize();
1893 }
1894
1895 //test case13.
1896 void    replication_refer_lock_mutex_test( int proto ){
1897     get_string_stubmode = 0;
1898     get_int_stubmode = 0;
1899     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1900     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1901     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1902     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1903     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1904     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1905     get_int_table[0] = 10000;                        //    "interval"
1906     get_int_table[1] = 64;                            //    "cmponent_size_00"
1907     get_int_table[2] = 1;                            //    "cmponent_size_01"
1908     get_int_table[3] = 200;                            //    "cmponent_size_02"
1909     get_int_table[4] = 10;                            //    "compulsorily_interval"
1910
1911     l7vs::replication_fake    repli1;
1912
1913     l7vs::replication::mutex_ptr mutex1, mutex2, mutex3, mutex4;
1914
1915     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
1916     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
1917     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
1918
1919
1920     // unit_test[131]  refer_lock_mutexのテスト("virtualservice")
1921     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1922     BOOST_CHECK_EQUAL( repli1.refer_lock_mutex( "virtualservice", mutex1 ), 0 );
1923     mutex1->lock();
1924     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1925     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1926     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1927
1928     // unit_test[132]  refer_lock_mutexのテスト(再度"virtualservice")
1929     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1930     BOOST_CHECK_EQUAL( repli1.refer_lock_mutex( "virtualservice", mutex1 ), 0 );
1931 //    mutex1->lock();                                                        // 一度帰ってこなくなるのを確認したらオミット
1932     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), true );
1933     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1934     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1935     mutex1->unlock();
1936     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1937
1938     // unit_test[133]  refer_lock_mutexのテスト("chash")
1939     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1940     BOOST_CHECK_EQUAL( repli1.refer_lock_mutex( "chash", mutex2 ), 0 );
1941     mutex2->lock();
1942     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1943     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1944     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1945
1946     // unit_test[134]  refer_lock_mutexのテスト(再度"chash")
1947     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1948     BOOST_CHECK_EQUAL( repli1.refer_lock_mutex( "chash", mutex2 ), 0 );
1949 //    mutex2->lock();                                                        // 一度帰ってこなくなるのを確認したらオミット
1950     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1951     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), true );
1952     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1953     mutex2->unlock();
1954     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1955
1956     // unit_test[135]  refer_lock_mutexのテスト("sslid")
1957     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1958     BOOST_CHECK_EQUAL( repli1.refer_lock_mutex( "sslid", mutex3 ), 0 );
1959     mutex3->lock();
1960     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1961     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1962     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1963
1964     // unit_test[136]  refer_lock_mutexのテスト(再度"sslid")
1965     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1966     BOOST_CHECK_EQUAL( repli1.refer_lock_mutex( "sslid", mutex3 ), 0 );
1967 //    mutex3->lock();                                                        // 一度帰ってこなくなるのを確認したらオミット
1968     BOOST_CHECK_EQUAL( repli1.locked( "virtualservice" ), false );
1969     BOOST_CHECK_EQUAL( repli1.locked( "chash" ), false );
1970     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), true );
1971     mutex3->unlock();
1972     BOOST_CHECK_EQUAL( repli1.locked( "sslid" ), false );
1973
1974     // unit_test[137]  refer_lock_mutexのテスト(不正なid)
1975     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
1976     BOOST_CHECK_EQUAL( repli1.refer_lock_mutex( "unknown", mutex4 ), -1 );
1977
1978     repli1.finalize();
1979 }
1980
1981 //test case14.
1982 void    replication_handle_send_test( int proto ){
1983     get_string_stubmode = 0;
1984     get_int_stubmode = 0;
1985     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
1986     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
1987     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
1988     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
1989     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
1990     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
1991     get_int_table[0] = 10000;                        //    "interval"
1992     get_int_table[1] = 64;                            //    "cmponent_size_00"
1993     get_int_table[2] = 1;                            //    "cmponent_size_01"
1994     get_int_table[3] = 200;                            //    "cmponent_size_02"
1995     get_int_table[4] = 10;                            //    "compulsorily_interval"
1996
1997     l7vs::replication    repli1;
1998
1999     get_int_table[1] = 1;                            //    "cmponent_size_00"
2000     get_int_table[2] = 1;                            //    "cmponent_size_01"
2001     get_int_table[3] = 1;                            //    "cmponent_size_02"
2002
2003     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2004
2005     // unit_test[138]  send_thread&handle_sendのテスト(SLAVE時)
2006     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2007     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
2008     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2009
2010     unsigned int    size;
2011     void*            ptr;
2012
2013     ptr = repli1.pay_memory( "virtualservice", size );
2014     BOOST_CHECK( NULL != ptr );
2015     BOOST_CHECK_EQUAL( repli1.lock( "virtualservice" ), 0 );
2016     memset( ptr, '4', size * DATA_SIZE );
2017     repli1.unlock( "virtualservice" );
2018
2019     ptr = repli1.pay_memory( "chash", size );
2020     BOOST_CHECK( NULL != ptr );
2021     BOOST_CHECK_EQUAL( repli1.lock( "chash" ), 0 );
2022     memset( ptr, '5', size * DATA_SIZE );
2023     repli1.unlock( "chash" );
2024
2025     ptr = repli1.pay_memory( "sslid", size );
2026     BOOST_CHECK( NULL != ptr );
2027     BOOST_CHECK_EQUAL( repli1.lock( "sslid" ), 0 );
2028     memset( ptr, '6', size * DATA_SIZE );
2029     repli1.unlock( "sslid" );
2030
2031     // unit_test[139]  send_thread&handle_sendのテスト(SLAVE_STOP時)
2032     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2033     repli1.stop();
2034     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
2035
2036     // unit_test[140]  send_thread&handle_sendのテスト(MASTER_STOP時)
2037     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2038     repli1.switch_to_master();
2039
2040     receiver_end = false;
2041     boost::thread    thread_item1( boost::bind ( &receiver_thread, recv_ip_table[proto] ) );
2042
2043     // unit_test[141]  send_thread&handle_sendのテスト(MASTER時)
2044     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2045     repli1.start();
2046     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
2047     while( !receiver_end );
2048     repli1.stop();
2049
2050     thread_item1.join();
2051     BOOST_CHECK( 1 );
2052
2053     repli1.finalize();
2054 }
2055
2056 //test case15.
2057 void    replication_set_master_test( int proto ){
2058     get_string_stubmode = 0;
2059     get_int_stubmode = 0;
2060     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2061     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2062     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2063     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2064     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2065     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2066     get_int_table[0] = 10000;                        //    "interval"
2067     get_int_table[1] = 64;                            //    "cmponent_size_00"
2068     get_int_table[2] = 1;                            //    "cmponent_size_01"
2069     get_int_table[3] = 200;                            //    "cmponent_size_02"
2070     get_int_table[4] = 10;                            //    "compulsorily_interval"
2071
2072     l7vs::replication_fake    repli1;
2073
2074     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2075     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
2076     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2077     repli1.disable_send_thread();
2078
2079     // unit_test[142]  set_masterのテスト(SLAVE時)
2080     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2081
2082     BOOST_CHECK_EQUAL( repli1.set_master_wrapper(), 0 );
2083     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );    // switch_toではないのでSLAVEのまま
2084     BOOST_CHECK_EQUAL( repli1.set_slave_wrapper(), 0 );                                // socket.cancel2重回避
2085
2086     // unit_test[143]  set_masterのテスト(ip_adrが不正)
2087     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2088
2089     strcpy( get_string_table[0], "192:168:0:20" );            //    "ip_addr"
2090
2091     repli1.finalize();
2092     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2093     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
2094     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
2095
2096     BOOST_CHECK_EQUAL( repli1.set_master_wrapper(), 0 );                            // set_masterの時点ではendpointを使用していない
2097
2098     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2099
2100     repli1.finalize();
2101 }
2102
2103 //test case16.
2104 void    replication_set_slave_test( int proto ){
2105     get_string_stubmode = 0;
2106     get_int_stubmode = 0;
2107     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2108     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2109     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2110     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2111     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2112     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2113     get_int_table[0] = 10000;                        //    "interval"
2114     get_int_table[1] = 64;                            //    "cmponent_size_00"
2115     get_int_table[2] = 1;                            //    "cmponent_size_01"
2116     get_int_table[3] = 200;                            //    "cmponent_size_02"
2117     get_int_table[4] = 10;                            //    "compulsorily_interval"
2118
2119     l7vs::replication_fake    repli1;
2120
2121     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2122     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
2123     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2124     repli1.disable_send_thread();
2125     repli1.switch_to_master();
2126     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
2127
2128     // unit_test[144]  set_slaveのテスト(MASTER時)
2129     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2130
2131     BOOST_CHECK_EQUAL( repli1.set_slave_wrapper(), 0 );
2132     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );    // switch_toではないのでMASTERのまま
2133     repli1.switch_to_slave();                                                            // 保険
2134
2135     // unit_test[145]  set_slaveのテスト(ip_adrが不正)
2136     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2137
2138     strcpy( get_string_table[0], "192:168:0:20" );            //    "ip_addr"
2139 //    get_string_table[0] = "10.144.169.87";            //    "ip_addr"                        作成失敗だと0.0.0.0:0でbind成功してしまうので使えないIPで
2140
2141     repli1.finalize();
2142     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2143     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
2144     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
2145
2146 //    BOOST_CHECK_EQUAL( repli1.set_slave_wrapper(), -1 );                                // 無理？
2147
2148     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2149
2150     repli1.finalize();
2151 }
2152
2153 //test case17.
2154 void    replication_check_parameter_test( int proto ){
2155     get_string_stubmode = 0;
2156     get_int_stubmode = 0;
2157     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2158     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2159     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2160     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2161     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2162     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2163     get_int_table[0] = 10000;                        //    "interval"
2164     get_int_table[1] = 64;                            //    "cmponent_size_00"
2165     get_int_table[2] = 1;                            //    "cmponent_size_01"
2166     get_int_table[3] = 200;                            //    "cmponent_size_02"
2167     get_int_table[4] = 10;                            //    "compulsorily_interval"
2168
2169     l7vs::replication_fake    repli1;
2170
2171     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2172     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
2173     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2174
2175     // unit_test[146]  check_parameterのテスト(正常系)
2176     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2177
2178     BOOST_CHECK_EQUAL( repli1.check_parameter_wrapper(), 0 );    // 異常系はinitializeにて評価済み
2179
2180     repli1.finalize();
2181 }
2182
2183 //test case18.
2184 void    replication_getrpl_test( int proto ){
2185     get_string_stubmode = 0;
2186     get_int_stubmode = 0;
2187     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2188     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2189     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2190     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2191     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2192     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2193     get_int_table[0] = 10000;                        //    "interval"
2194     get_int_table[1] = 64;                            //    "cmponent_size_00"
2195     get_int_table[2] = 1;                            //    "cmponent_size_01"
2196     get_int_table[3] = 200;                            //    "cmponent_size_02"
2197     get_int_table[4] = 10;                            //    "compulsorily_interval"
2198
2199     l7vs::replication_fake    repli1;
2200
2201     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2202     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );    // param読み込みのため1回実行
2203     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2204
2205     repli1.finalize();
2206
2207     // unit_test[147]  getrplのテスト(正常系)
2208     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2209
2210     BOOST_CHECK( NULL != repli1.getrpl_wrapper() );    // 異常系はinitializeにて評価済み
2211     repli1.releaserpl_wrapper();
2212
2213     repli1.finalize();
2214 }
2215
2216 //test case19.
2217 void    replication_getcmp_test( int proto ){
2218     get_string_stubmode = 0;
2219     get_int_stubmode = 0;
2220     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2221     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2222     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2223     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2224     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2225     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2226     get_int_table[0] = 10000;                        //    "interval"
2227     get_int_table[1] = 64;                            //    "cmponent_size_00"
2228     get_int_table[2] = 1;                            //    "cmponent_size_01"
2229     get_int_table[3] = 200;                            //    "cmponent_size_02"
2230     get_int_table[4] = 10;                            //    "compulsorily_interval"
2231
2232     l7vs::replication_fake    repli1;
2233
2234     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2235     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );    // param読み込みのため1回実行
2236     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2237
2238     repli1.finalize();
2239
2240     // unit_test[148]  getcmpのテスト(正常系)
2241     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2242
2243     BOOST_CHECK( NULL != repli1.getcmp_wrapper() );    // 異常系はinitializeにて評価済み
2244     repli1.releasecmp_wrapper();
2245
2246     repli1.finalize();
2247 }
2248
2249 //test case20.
2250 void    replication_getsrf_test( int proto ){
2251     get_string_stubmode = 0;
2252     get_int_stubmode = 0;
2253     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2254     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2255     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2256     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2257     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2258     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2259     get_int_table[0] = 10000;                        //    "interval"
2260     get_int_table[1] = 64;                            //    "cmponent_size_00"
2261     get_int_table[2] = 1;                            //    "cmponent_size_01"
2262     get_int_table[3] = 200;                            //    "cmponent_size_02"
2263     get_int_table[4] = 10;                            //    "compulsorily_interval"
2264
2265     l7vs::replication_fake    repli1;
2266
2267     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2268     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );    // param読み込みのため1回実行
2269     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2270
2271     repli1.finalize();
2272
2273     // unit_test[149]  getsrfのテスト(正常系)
2274     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2275
2276     BOOST_CHECK( NULL != repli1.getsrf_wrapper() );    // 異常系はinitializeにて評価済み
2277     repli1.releasesrf_wrapper();
2278
2279     repli1.finalize();
2280 }
2281
2282 //test case21.
2283 void    replication_make_serial_test( int proto ){
2284     get_string_stubmode = 0;
2285     get_int_stubmode = 0;
2286     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2287     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2288     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2289     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2290     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2291     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2292     get_int_table[0] = 10000;                        //    "interval"
2293     get_int_table[1] = 64;                            //    "cmponent_size_00"
2294     get_int_table[2] = 1;                            //    "cmponent_size_01"
2295     get_int_table[3] = 200;                            //    "cmponent_size_02"
2296     get_int_table[4] = 10;                            //    "compulsorily_interval"
2297
2298     l7vs::replication_fake    repli1;
2299     unsigned long long        value1, value2;
2300
2301     // unit_test[150]  make_serialのテスト(正常系)
2302     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2303
2304     value1 = repli1.make_serial_wrapper();
2305     BOOST_CHECK( 0 != value1 );
2306
2307     // unit_test[151]  make_serialのテスト(再実行)
2308     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2309
2310     value2 = repli1.make_serial_wrapper();
2311     BOOST_CHECK( 0 != value1 );
2312     BOOST_CHECK( value1 != value2 );
2313
2314     repli1.finalize();
2315 }
2316
2317 //test case22.
2318 void    replication_releaserpl_test( int proto ){
2319     get_string_stubmode = 0;
2320     get_int_stubmode = 0;
2321     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2322     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2323     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2324     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2325     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2326     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2327     get_int_table[0] = 10000;                        //    "interval"
2328     get_int_table[1] = 64;                            //    "cmponent_size_00"
2329     get_int_table[2] = 1;                            //    "cmponent_size_01"
2330     get_int_table[3] = 200;                            //    "cmponent_size_02"
2331     get_int_table[4] = 10;                            //    "compulsorily_interval"
2332
2333     l7vs::replication_fake    repli1;
2334
2335     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2336     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );    // param読み込みのため1回実行
2337     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2338
2339     repli1.finalize();
2340
2341     // unit_test[152]  releaserplのテスト(正常系)
2342     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2343
2344     BOOST_CHECK( NULL != repli1.getrpl_wrapper() );
2345     BOOST_CHECK( NULL == repli1.releaserpl_wrapper() );
2346
2347     repli1.finalize();
2348 }
2349
2350 //test case23.
2351 void    replication_releasecmp_test( int proto ){
2352     get_string_stubmode = 0;
2353     get_int_stubmode = 0;
2354     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2355     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2356     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2357     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2358     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2359     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2360     get_int_table[0] = 10000;                        //    "interval"
2361     get_int_table[1] = 64;                            //    "cmponent_size_00"
2362     get_int_table[2] = 1;                            //    "cmponent_size_01"
2363     get_int_table[3] = 200;                            //    "cmponent_size_02"
2364     get_int_table[4] = 10;                            //    "compulsorily_interval"
2365
2366     l7vs::replication_fake    repli1;
2367
2368     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2369     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );    // param読み込みのため1回実行
2370     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2371
2372     repli1.finalize();
2373
2374     // unit_test[153]  releasecmpのテスト(正常系)
2375     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2376
2377     BOOST_CHECK( NULL != repli1.getcmp_wrapper() );
2378     BOOST_CHECK( NULL == repli1.releasecmp_wrapper() );
2379
2380     repli1.finalize();
2381 }
2382
2383 //test case24.
2384 void    replication_releasesrf_test( int proto ){
2385     get_string_stubmode = 0;
2386     get_int_stubmode = 0;
2387     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2388     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2389     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2390     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2391     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2392     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2393     get_int_table[0] = 10000;                        //    "interval"
2394     get_int_table[1] = 64;                            //    "cmponent_size_00"
2395     get_int_table[2] = 1;                            //    "cmponent_size_01"
2396     get_int_table[3] = 200;                            //    "cmponent_size_02"
2397     get_int_table[4] = 10;                            //    "compulsorily_interval"
2398
2399     l7vs::replication_fake    repli1;
2400
2401     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2402     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );    // param読み込みのため1回実行
2403     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2404
2405     repli1.finalize();
2406
2407     // unit_test[154]  releasesrfのテスト(正常系)
2408     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2409
2410     BOOST_CHECK( NULL != repli1.getsrf_wrapper() );
2411     BOOST_CHECK( NULL == repli1.releasesrf_wrapper() );
2412
2413     repli1.finalize();
2414 }
2415
2416 //test case25.
2417 void    replication_finalize_test( int proto ){
2418     get_string_stubmode = 0;
2419     get_int_stubmode = 0;
2420     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2421     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2422     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2423     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2424     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2425     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2426     get_int_table[0] = 10000;                        //    "interval"
2427     get_int_table[1] = 64;                            //    "cmponent_size_00"
2428     get_int_table[2] = 1;                            //    "cmponent_size_01"
2429     get_int_table[3] = 200;                            //    "cmponent_size_02"
2430     get_int_table[4] = 10;                            //    "compulsorily_interval"
2431
2432     l7vs::replication    repli1;
2433
2434     // unit_test[155]  finalizeのテスト(未初期化)
2435     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2436     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2437     repli1.finalize();
2438     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2439
2440     // unit_test[156]  finalizeのテスト(SLAVE時)
2441     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2442     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
2443     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2444     repli1.finalize();
2445     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2446
2447     // unit_test[157]  finalizeのテスト(MASTER時)
2448     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2449     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
2450     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2451     repli1.switch_to_master();
2452     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
2453     repli1.finalize();
2454     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2455
2456     // unit_test[158]  finalizeのテスト(MASTER_STOP時)
2457     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2458     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
2459     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2460     repli1.switch_to_master();
2461     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
2462     repli1.stop();
2463     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER_STOP );
2464     repli1.finalize();
2465     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2466
2467     // unit_test[159]  finalizeのテスト(SLAVE_STOP)
2468     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2469     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
2470     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2471     repli1.stop();
2472     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE_STOP );
2473     repli1.finalize();
2474     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2475
2476     // unit_test[160]  finalizeのテスト(SINGLE時)
2477     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2478     get_string_stubmode = 1;
2479     get_int_stubmode = 1;
2480     BOOST_CHECK_EQUAL( repli1.initialize(), -1 );
2481     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SINGLE );
2482     repli1.finalize();
2483     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2484
2485     get_string_stubmode = 0;
2486     get_int_stubmode = 0;
2487 }
2488
2489
2490 //test case26.
2491 void    replication_handle_receive_test( int proto ){
2492     get_string_stubmode = 0;
2493     get_int_stubmode = 0;
2494     strcpy( get_string_table[0], target_ip_table[proto] );            //    "ip_addr"
2495     strcpy( get_string_table[1], REPLICATION_PORT );                    //    "service_name"
2496     strcpy( get_string_table[2], recv_ip_table[proto] );                    //    "recv_ip_addr"
2497     strcpy( get_string_table[3], "virtualservice" );            //    "cmponent_id_00"
2498     strcpy( get_string_table[4], "chash" );                    //    "cmponent_id_01"
2499     strcpy( get_string_table[5], "sslid" );                    //    "cmponent_id_02"
2500     get_int_table[0] = 10000;                        //    "interval"
2501     get_int_table[1] = 64;                            //    "cmponent_size_00"
2502     get_int_table[2] = 1;                            //    "cmponent_size_01"
2503     get_int_table[3] = 200;                            //    "cmponent_size_02"
2504     get_int_table[4] = 10;                            //    "compulsorily_interval"
2505
2506     l7vs::replication    repli1;
2507
2508     //get_string_table[0] = TARGET_HOSTNAME;                    //    "ip_addr"
2509     strcpy( get_string_table[0], target_ip_table[proto] );                    //    "ip_addr"
2510     get_int_table[1] = 1;                            //    "cmponent_size_00"
2511     get_int_table[2] = 1;                            //    "cmponent_size_01"
2512     get_int_table[3] = 1;                            //    "cmponent_size_02"
2513
2514     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_OUT );
2515
2516     BOOST_CHECK_EQUAL( repli1.initialize(), 0 );
2517     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2518
2519     // unit_test[161]  handle_receiveのテスト(正常系)
2520     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2521
2522     {
2523         boost::thread    thread_item( boost::bind ( &sender2_thread, target_ip_table[proto] ) );
2524
2525         thread_item.join();
2526     }
2527
2528     repli1.dump_memory();
2529     BOOST_CHECK( 1 );
2530
2531     // unit_test[162]  handle_receiveのテスト(MASTER → SLAVE時)
2532     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2533
2534     unsigned int    size;
2535     void*            ptr;
2536
2537     ptr = repli1.pay_memory( "virtualservice", size );
2538     BOOST_CHECK( NULL != ptr );
2539     BOOST_CHECK_EQUAL( repli1.lock( "virtualservice" ), 0 );
2540     memset( ptr, 0xFF, size * DATA_SIZE );
2541     repli1.unlock( "virtualservice" );
2542
2543     ptr = repli1.pay_memory( "chash", size );
2544     BOOST_CHECK( NULL != ptr );
2545     BOOST_CHECK_EQUAL( repli1.lock( "chash" ), 0 );
2546     memset( ptr, 0xFF, size * DATA_SIZE );
2547     repli1.unlock( "chash" );
2548
2549     ptr = repli1.pay_memory( "sslid", size );
2550     BOOST_CHECK( NULL != ptr );
2551     BOOST_CHECK_EQUAL( repli1.lock( "sslid" ), 0 );
2552     memset( ptr, 0xFF, size * DATA_SIZE );
2553     repli1.unlock( "sslid" );
2554
2555     repli1.switch_to_master();
2556     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_MASTER );
2557
2558     {
2559         receiver_end = false;
2560         boost::thread    thread_item( boost::bind ( &receiver_thread, recv_ip_table[proto] ) );
2561
2562         while( !receiver_end ){
2563             global_receive_io.poll();
2564         }
2565
2566         thread_item.join();
2567     }
2568
2569     repli1.switch_to_slave();
2570     BOOST_CHECK_EQUAL( repli1.get_status(), l7vs::replication::REPLICATION_SLAVE );
2571
2572     {
2573         boost::thread    thread_item( boost::bind ( &sender2_thread, target_ip_table[proto] ) );
2574
2575         thread_item.join();
2576     }
2577
2578     repli1.dump_memory();
2579     BOOST_CHECK( 1 );
2580
2581 /*
2582     // unit_test[163]  handle_receiveのテスト(replication対replication)
2583     BOOST_MESSAGE( boost::format( "unit_test[%d]" ) % ++count );
2584
2585     boost::thread    thread_item2( boost::bind ( &sender_thread ) );
2586
2587     sleep(1);
2588
2589     thread_item2.join();
2590
2591     repli1.dump_memory();
2592     BOOST_CHECK( 1 );
2593
2594     get_int_table[1] = 64;                            //    "cmponent_size_00"
2595     get_int_table[2] = 1;                            //    "cmponent_size_01"
2596     get_int_table[3] = 200;                            //    "cmponent_size_02"
2597 */
2598     repli1.finalize();
2599 }
2600
2601 test_suite*    init_unit_test_suite( int argc, char* argv[] ){
2602     l7vs::Logger    logger;
2603     l7vs::Parameter    parameter;
2604
2605     logger.loadConf();
2606
2607     // create unit test suite
2608     test_suite* ts = BOOST_TEST_SUITE( "replication_test" );
2609
2610     int protos[] = { 0, 1 };
2611
2612     // add test case to test suite
2613     ts->add( BOOST_PARAM_TEST_CASE( &replication_initialize_test, protos, protos+2 ) );
2614     ts->add( BOOST_PARAM_TEST_CASE( &replication_switch_to_master_test, protos, protos+2 ) );
2615     ts->add( BOOST_PARAM_TEST_CASE( &replication_switch_to_slave_test, protos, protos+2 ) );
2616     ts->add( BOOST_PARAM_TEST_CASE( &replication_pay_memory_test, protos, protos+2 ) );
2617     ts->add( BOOST_PARAM_TEST_CASE( &replication_dump_memory_test, protos, protos+2 ) );
2618     ts->add( BOOST_PARAM_TEST_CASE( &replication_start_test, protos, protos+2 ) );
2619     ts->add( BOOST_PARAM_TEST_CASE( &replication_stop_test, protos, protos+2 ) );
2620
2621     ts->add( BOOST_PARAM_TEST_CASE( &replication_force_replicate_test, protos, protos+2 ) );
2622
2623     ts->add( BOOST_PARAM_TEST_CASE( &replication_reset_test, protos, protos+2 ) );
2624     ts->add( BOOST_PARAM_TEST_CASE( &replication_get_status_test, protos, protos+2 ) );
2625     ts->add( BOOST_PARAM_TEST_CASE( &replication_lock_test, protos, protos+2 ) );
2626     ts->add( BOOST_PARAM_TEST_CASE( &replication_unlock_test, protos, protos+2 ) );
2627     ts->add( BOOST_PARAM_TEST_CASE( &replication_refer_lock_mutex_test, protos, protos+2 ) );
2628
2629     ts->add( BOOST_PARAM_TEST_CASE( &replication_handle_send_test, protos, protos+2 ) );
2630     ts->add( BOOST_PARAM_TEST_CASE( &replication_set_master_test, protos, protos+2 ) );
2631     ts->add( BOOST_PARAM_TEST_CASE( &replication_set_slave_test, protos, protos+2 ) );
2632     ts->add( BOOST_PARAM_TEST_CASE( &replication_check_parameter_test, protos, protos+2 ) );
2633     ts->add( BOOST_PARAM_TEST_CASE( &replication_getrpl_test, protos, protos+2 ) );
2634     ts->add( BOOST_PARAM_TEST_CASE( &replication_getcmp_test, protos, protos+2 ) );
2635     ts->add( BOOST_PARAM_TEST_CASE( &replication_getsrf_test, protos, protos+2 ) );
2636     ts->add( BOOST_PARAM_TEST_CASE( &replication_make_serial_test, protos, protos+2 ) );
2637     ts->add( BOOST_PARAM_TEST_CASE( &replication_releaserpl_test, protos, protos+2 ) );
2638     ts->add( BOOST_PARAM_TEST_CASE( &replication_releasecmp_test, protos, protos+2 ) );
2639     ts->add( BOOST_PARAM_TEST_CASE( &replication_releasesrf_test, protos, protos+2 ) );
2640     ts->add( BOOST_PARAM_TEST_CASE( &replication_finalize_test, protos, protos+2 ) );
2641
2642     ts->add( BOOST_PARAM_TEST_CASE( &replication_handle_receive_test, protos, protos+2 ) );
2643
2644     framework::master_test_suite().add( ts );
2645
2646     return 0;
2647 }
2648