开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
main.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：25k
源码类别：

MySQL数据库

开发平台：

Visual C++

main.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. #include <ndb_global.h>
  19. #include <getarg.h>
  20. #include <BaseString.hpp>
  21. #include <Parser.hpp>
  22. #include <NdbOut.hpp>
  23. #include <Properties.hpp>
  24. #include <NdbAutoPtr.hpp>
  26. #include "run-test.hpp"
  27. #include <SysLogHandler.hpp>
  28. #include <FileLogHandler.hpp>
  30. #include <mgmapi.h>
  31. #include "CpcClient.hpp"
  33. /** Global variables */
  34. static const char progname[] = "ndb_atrt";
  35. static const char * g_gather_progname = "atrt-gather-result.sh";
  36. static const char * g_analyze_progname = "atrt-analyze-result.sh";
  37. static const char * g_clear_progname = "atrt-clear-result.sh";
  38. static const char * g_setup_progname = "atrt-setup.sh";
  40. static const char * g_setup_path = 0;
  41. static const char * g_process_config_filename = "d.txt";
  42. static const char * g_log_filename = 0;
  43. static const char * g_test_case_filename = 0;
  44. static const char * g_report_filename = 0;
  46. static const char * g_default_user = 0;
  47. static const char * g_default_base_dir = 0;
  48. static int          g_default_base_port = 0;
  49. static int          g_mysqld_use_base = 1;
  51. static int g_report = 0;
  52. static int g_verbosity = 0;
  53. static FILE * g_report_file = 0;
  54. static FILE * g_test_case_file = stdin;
  56. Logger g_logger;
  57. atrt_config g_config;
  59. static int g_mode_bench = 0;
  60. static int g_mode_regression = 0;
  61. static int g_mode_interactive = 0;
  62. static int g_mode = 0;
  64. static
  65. struct getargs args[] = {
  66.   { "process-config", 0, arg_string, &g_process_config_filename, 0, 0 },
  67.   { "setup-path", 0, arg_string, &g_setup_path, 0, 0 },
  68.   { 0, 'v', arg_counter, &g_verbosity, 0, 0 },
  69.   { "log-file", 0, arg_string, &g_log_filename, 0, 0 },
  70.   { "testcase-file", 'f', arg_string, &g_test_case_filename, 0, 0 },
  71.   { 0, 'R', arg_flag, &g_report, 0, 0 },
  72.   { "report-file", 0, arg_string, &g_report_filename, 0, 0 },
  73.   { "interactive", 'i', arg_flag, &g_mode_interactive, 0, 0 },
  74.   { "regression", 'r', arg_flag, &g_mode_regression, 0, 0 },
  75.   { "bench", 'b', arg_flag, &g_mode_bench, 0, 0 },
  76. };
  78. const int arg_count = 10;
  80. int
  81. main(int argc, const char ** argv){
  82.   ndb_init();
  83.   
  84.   bool restart = true;
  85.   int lineno = 1;
  86.   int test_no = 1; 
  88.   const int p_ndb     = atrt_process::NDB_MGM | atrt_process::NDB_DB;
  89.   const int p_servers = atrt_process::MYSQL_SERVER | atrt_process::NDB_REP;
  90.   const int p_clients = atrt_process::MYSQL_CLIENT | atrt_process::NDB_API;
  91.   
  92.   g_logger.setCategory(progname);
  93.   g_logger.enable(Logger::LL_ALL);
  94.   g_logger.createConsoleHandler();
  95.   
  96.   if(!parse_args(argc, argv))
  97.     goto end;
  99.   g_logger.info("Starting...");
  100.   if(!setup_config(g_config))
  101.     goto end;
  102.   
  103.   g_logger.info("Connecting to hosts");
  104.   if(!connect_hosts(g_config))
  105.     goto end;
  107.   if(!setup_hosts(g_config))
  108.     goto end;
  110.   /**
  111.    * Main loop
  112.    */
  113.   while(!feof(g_test_case_file)){
  114.     /**
  115.      * Do we need to restart ndb
  116.      */
  117.     if(restart){
  118.       g_logger.info("(Re)starting ndb processes");
  119.       if(!stop_processes(g_config, ~0))
  120. goto end;
  122.       if(!start_processes(g_config, atrt_process::NDB_MGM))
  123. goto end;
  124.       
  125.       if(!connect_ndb_mgm(g_config)){
  126. goto end;
  127.       }
  128.       
  129.       if(!start_processes(g_config, atrt_process::NDB_DB))
  130. goto end;
  131.       
  132.       if(!wait_ndb(g_config, NDB_MGM_NODE_STATUS_NOT_STARTED))
  133.         goto end;
  134.       
  135.       for(Uint32 i = 0; i<3; i++)      
  136.         if(wait_ndb(g_config, NDB_MGM_NODE_STATUS_STARTED))
  137.   goto started;
  138.       
  139.       goto end;
  140.       
  141.     started:
  142.       if(!start_processes(g_config, p_servers))
  143.         goto end;
  145.       g_logger.info("Ndb start completed");
  146.     }
  147.     
  148.     const int start_line = lineno;
  149.     atrt_testcase test_case;
  150.     if(!read_test_case(g_test_case_file, test_case, lineno))
  151.       goto end;
  152.     
  153.     g_logger.info("#%d - %s %s", 
  154.   test_no,
  155.   test_case.m_command.c_str(), test_case.m_args.c_str());
  156.     
  157.     // Assign processes to programs
  158.     if(!setup_test_case(g_config, test_case))
  159.       goto end;
  160.     
  161.     if(!start_processes(g_config, p_clients))
  162.       goto end;
  164.     int result = 0;
  165.     
  166.     const time_t start = time(0);
  167.     time_t now = start;
  168.     do {
  169.       if(!update_status(g_config, atrt_process::ALL))
  170. goto end;
  172.       int count = 0;
  174.       if((count = is_running(g_config, p_ndb)) != 2){
  175. result = ERR_NDB_FAILED;
  176. break;
  177.       }
  179.       if((count = is_running(g_config, p_servers)) != 2){
  180. result = ERR_SERVERS_FAILED;
  181. break;
  182.       }
  184.       if((count = is_running(g_config, p_clients)) == 0){
  185. break;
  186.       }
  187.       
  188.       now = time(0);
  189.       if(now  > (start + test_case.m_max_time)){
  190. result = ERR_MAX_TIME_ELAPSED;
  191. break;
  192.       }
  193.       sleep(1);
  194.     } while(true);
  195.     
  196.     const time_t elapsed = time(0) - start;
  197.    
  198.     if(!stop_processes(g_config, p_clients))
  199.       goto end;
  200.     
  201.     if(!gather_result(g_config, &result))
  202.       goto end;
  203.     
  204.     g_logger.info("#%d %s(%d)", 
  205.   test_no, 
  206.   (result == 0 ? "OK" : "FAILED"), result);
  208.     if(g_report_file != 0){
  209.       fprintf(g_report_file, "%s %s ; %d ; %d ; %ldn",
  210.       test_case.m_command.c_str(),
  211.       test_case.m_args.c_str(),
  212.       test_no, result, elapsed);
  213.       fflush(g_report_file);
  214.     }    
  216.     if(test_case.m_report || g_mode_bench || (g_mode_regression && result)){
  217.       BaseString tmp;
  218.       tmp.assfmt("result.%d", test_no);
  219.       if(rename("result", tmp.c_str()) != 0){
  220. g_logger.critical("Failed to rename %s as %s",
  221.   "result", tmp.c_str());
  222. goto end;
  223.       }
  224.     }
  225.     
  226.     if(g_mode_interactive && result){
  227.       g_logger.info
  228. ("Encountered failed test in interactive mode - terminating");
  229.       break;
  230.     }
  232.     if(result != 0){
  233.       restart = true;
  234.     } else {
  235.       restart = false;
  236.     }
  237.     test_no++;
  238.   }
  239.   
  240.  end:
  241.   if(g_report_file != 0){
  242.     fclose(g_report_file);
  243.     g_report_file = 0;
  244.   }
  246.   if(g_test_case_file != 0 && g_test_case_file != stdin){
  247.     fclose(g_test_case_file);
  248.     g_test_case_file = 0;
  249.   }
  251.   stop_processes(g_config, atrt_process::ALL);
  252.   return 0;
  253. }
  255. bool
  256. parse_args(int argc, const char** argv){
  257.   int optind = 0;
  258.   if(getarg(args, arg_count, argc, argv, &optind)) {
  259.     arg_printusage(args, arg_count, progname, "");
  260.     return false;
  261.   }
  263.   if(g_log_filename != 0){
  264.     g_logger.removeConsoleHandler();
  265.     g_logger.addHandler(new FileLogHandler(g_log_filename));
  266.   }
  268.   {
  269.     int tmp = Logger::LL_WARNING - g_verbosity;
  270.     tmp = (tmp < Logger::LL_DEBUG ? Logger::LL_DEBUG : tmp);
  271.     g_logger.disable(Logger::LL_ALL);
  272.     g_logger.enable(Logger::LL_ON);
  273.     g_logger.enable((Logger::LoggerLevel)tmp, Logger::LL_ALERT);
  274.   }
  278.   if(!g_process_config_filename){
  279.     g_logger.critical("Process config not specified!");
  280.     return false;
  281.   }
  282.   
  283.   if(!g_setup_path){
  284.     char buf[1024];
  285.     if(getcwd(buf, sizeof(buf))){
  286.       g_setup_path = strdup(buf);
  287.       g_logger.info("Setup path not specified, using %s", buf);
  288.     } else {
  289.       g_logger.critical("Setup path not specified!n");
  290.       return false;
  291.     }
  292.   }
  293.   
  294.   if(g_report & !g_report_filename){
  295.     g_report_filename = "report.txt";
  296.   }
  298.   if(g_report_filename){
  299.     g_report_file = fopen(g_report_filename, "w");
  300.     if(g_report_file == 0){
  301.       g_logger.critical("Unable to create report file: %s", g_report_filename);
  302.       return false;
  303.     }
  304.   }
  306.   if(g_test_case_filename){
  307.     g_test_case_file = fopen(g_test_case_filename, "r");
  308.     if(g_test_case_file == 0){
  309.       g_logger.critical("Unable to open file: %s", g_test_case_filename);
  310.       return false;
  311.     }
  312.   }
  313.   
  314.   int sum = g_mode_interactive + g_mode_regression + g_mode_bench;
  315.   if(sum == 0){
  316.     g_mode_interactive = 1;
  317.   }
  319.   if(sum > 1){
  320.     g_logger.critical
  321.       ("Only one of bench/regression/interactive can be specified");
  322.     return false;
  323.   }
  324.   
  325.   g_default_user = strdup(getenv("LOGNAME"));
  327.   return true;
  328. }
  331. static
  332. atrt_host *
  333. find(const BaseString& host, Vector<atrt_host> & hosts){
  334.   for(size_t i = 0; i<hosts.size(); i++){
  335.     if(hosts[i].m_hostname == host){
  336.       return &hosts[i];
  337.     }
  338.   }
  339.   return 0;
  340. }
  342. bool
  343. setup_config(atrt_config& config){
  345.   FILE * f = fopen(g_process_config_filename, "r");
  346.   if(!f){
  347.     g_logger.critical("Failed to open process config file: %s",
  348.       g_process_config_filename);
  349.     return false;
  350.   }
  351.   bool result = true;
  353.   int lineno = 0;
  354.   char buf[2048];
  355.   BaseString connect_string;
  356.   int mysql_port_offset = 0;
  357.   while(fgets(buf, 2048, f)){
  358.     lineno++;
  360.     BaseString tmp(buf);
  361.     tmp.trim(" tnr");
  363.     if(tmp.length() == 0 || tmp == "" || tmp.c_str()[0] == '#')
  364.       continue;
  366.     Vector<BaseString> split1;
  367.     if(tmp.split(split1, ":", 2) != 2){
  368.       g_logger.warning("Invalid line %d in %s - ignoring",
  369.        lineno, g_process_config_filename);
  370.       continue;
  371.     }
  373.     if(split1[0].trim() == "basedir"){
  374.       g_default_base_dir = strdup(split1[1].trim().c_str());
  375.       continue;
  376.     }
  378.     if(split1[0].trim() == "baseport"){
  379.       g_default_base_port = atoi(split1[1].trim().c_str());
  380.       continue;
  381.     }
  383.     if(split1[0].trim() == "user"){
  384.       g_default_user = strdup(split1[1].trim().c_str());
  385.       continue;
  386.     }
  388.     if(split1[0].trim() == "mysqld-use-base" && split1[1].trim() == "no"){
  389.       g_mysqld_use_base = 0;
  390.       continue;
  391.     }
  393.     Vector<BaseString> hosts;
  394.     if(split1[1].trim().split(hosts) <= 0){
  395.       g_logger.warning("Invalid line %d in %s - ignoring", 
  396.        lineno, g_process_config_filename);
  397.     }
  399.     // 1 - Check hosts
  400.     for(size_t i = 0; i<hosts.size(); i++){
  401.       Vector<BaseString> tmp;
  402.       hosts[i].split(tmp, ":");
  403.       BaseString hostname = tmp[0].trim();
  404.       BaseString base_dir;
  405.       if(tmp.size() >= 2)
  406.         base_dir = tmp[1];
  407.       else if(g_default_base_dir == 0){
  408. g_logger.critical("Basedir not specified...");
  409.         return false;
  410.       }
  412.       atrt_host * host_ptr;
  413.       if((host_ptr = find(hostname, config.m_hosts)) == 0){
  414. atrt_host host;
  415. host.m_index = config.m_hosts.size();
  416. host.m_cpcd = new SimpleCpcClient(hostname.c_str(), 1234);
  417. host.m_base_dir = (base_dir.empty() ? g_default_base_dir : base_dir);
  418. host.m_user = g_default_user;
  419. host.m_hostname = hostname.c_str();
  420. config.m_hosts.push_back(host);
  421.       } else {
  422.         if(!base_dir.empty() && (base_dir == host_ptr->m_base_dir)){
  423.           g_logger.critical("Inconsistent base dir definition for host %s"
  424.                             ", "%s" != "%s"", hostname.c_str(), 
  425.                             base_dir.c_str(), host_ptr->m_base_dir.c_str());
  426.           return false;
  427.         }
  428.       }
  429.     }
  430.     
  431.     for(size_t i = 0; i<hosts.size(); i++){
  432.       BaseString & tmp = hosts[i];
  433.       atrt_host * host = find(tmp, config.m_hosts);
  434.       BaseString & dir = host->m_base_dir;
  436.       const int index = config.m_processes.size() + 1;
  438.       atrt_process proc;
  439.       proc.m_index = index;
  440.       proc.m_host = host;
  441.       proc.m_proc.m_id = -1;
  442.       proc.m_proc.m_type = "temporary";
  443.       proc.m_proc.m_owner = "atrt";  
  444.       proc.m_proc.m_group = "group";    
  445.       proc.m_proc.m_cwd.assign(dir).append("/run/");
  446.       proc.m_proc.m_stdout = "log.out";
  447.       proc.m_proc.m_stderr = "2>&1";
  448.       proc.m_proc.m_runas = proc.m_host->m_user;
  449.       proc.m_proc.m_ulimit = "c:unlimited";
  450.       proc.m_proc.m_env.assfmt("MYSQL_BASE_DIR=%s", dir.c_str());
  451.       proc.m_proc.m_shutdown_options = "";
  452.       proc.m_hostname = proc.m_host->m_hostname;
  453.       proc.m_ndb_mgm_port = g_default_base_port;
  454.       if(split1[0] == "mgm"){
  455. proc.m_type = atrt_process::NDB_MGM;
  456. proc.m_proc.m_name.assfmt("%d-%s", index, "ndb_mgmd");
  457. proc.m_proc.m_path.assign(dir).append("/libexec/ndb_mgmd");
  458. proc.m_proc.m_args = "--nodaemon -f config.ini";
  459. proc.m_proc.m_cwd.appfmt("%d.ndb_mgmd", index);
  460. connect_string.appfmt("host=%s:%d;", 
  461.       proc.m_hostname.c_str(), proc.m_ndb_mgm_port);
  462.       } else if(split1[0] == "ndb"){
  463. proc.m_type = atrt_process::NDB_DB;
  464. proc.m_proc.m_name.assfmt("%d-%s", index, "ndbd");
  465. proc.m_proc.m_path.assign(dir).append("/libexec/ndbd");
  466. proc.m_proc.m_args = "--initial --nodaemon -n";
  467. proc.m_proc.m_cwd.appfmt("%d.ndbd", index);
  468.       } else if(split1[0] == "mysqld"){
  469. proc.m_type = atrt_process::MYSQL_SERVER;
  470. proc.m_proc.m_name.assfmt("%d-%s", index, "mysqld");
  471. proc.m_proc.m_path.assign(dir).append("/libexec/mysqld");
  472. proc.m_proc.m_args = "--core-file --ndbcluster";
  473. proc.m_proc.m_cwd.appfmt("%d.mysqld", index);
  474. proc.m_proc.m_shutdown_options = "SIGKILL"; // not nice
  475.       } else if(split1[0] == "api"){
  476. proc.m_type = atrt_process::NDB_API;
  477. proc.m_proc.m_name.assfmt("%d-%s", index, "ndb_api");
  478. proc.m_proc.m_path = "";
  479. proc.m_proc.m_args = "";
  480. proc.m_proc.m_cwd.appfmt("%d.ndb_api", index);
  481.       } else if(split1[0] == "mysql"){
  482.         proc.m_type = atrt_process::MYSQL_CLIENT;
  483.         proc.m_proc.m_name.assfmt("%d-%s", index, "mysql");
  484.         proc.m_proc.m_path = "";
  485.         proc.m_proc.m_args = "";
  486.         proc.m_proc.m_cwd.appfmt("%d.mysql", index);
  487.       } else {
  488. g_logger.critical("%s:%d: Unhandled process type: %s",
  489.   g_process_config_filename, lineno,
  490.   split1[0].c_str());
  491. result = false;
  492. goto end;
  493.       }
  494.       config.m_processes.push_back(proc);
  495.     }
  496.   }
  498.   // Setup connect string
  499.   for(size_t i = 0; i<config.m_processes.size(); i++){
  500.     config.m_processes[i].m_proc.m_env.appfmt(" NDB_CONNECTSTRING=%s", 
  501.       connect_string.c_str());
  502.   }
  503.   
  504.  end:
  505.   fclose(f);
  506.   return result;
  507. }
  509. bool
  510. connect_hosts(atrt_config& config){
  511.   for(size_t i = 0; i<config.m_hosts.size(); i++){
  512.     if(config.m_hosts[i].m_cpcd->connect() != 0){
  513.       g_logger.error("Unable to connect to cpc %s:%d",
  514.      config.m_hosts[i].m_cpcd->getHost(),
  515.      config.m_hosts[i].m_cpcd->getPort());
  516.       return false;
  517.     }
  518.     g_logger.debug("Connected to %s:%d",
  519.    config.m_hosts[i].m_cpcd->getHost(),
  520.    config.m_hosts[i].m_cpcd->getPort());
  521.   }
  522.   
  523.   return true;
  524. }
  526. bool
  527. connect_ndb_mgm(atrt_process & proc){
  528.   NdbMgmHandle handle = ndb_mgm_create_handle();
  529.   if(handle == 0){
  530.     g_logger.critical("Unable to create mgm handle");
  531.     return false;
  532.   }
  533.   BaseString tmp = proc.m_hostname;
  534.   tmp.appfmt(":%d", proc.m_ndb_mgm_port);
  536.   if (ndb_mgm_set_connectstring(handle,tmp.c_str()))
  537.   {
  538.     g_logger.critical("Unable to create parse connectstring");
  539.     return false;
  540.   }
  542.   if(ndb_mgm_connect(handle, 30, 1, 0) != -1)
  543.   {
  544.     proc.m_ndb_mgm_handle = handle;
  545.     return true;
  546.   }
  548.   g_logger.critical("Unable to connect to ndb mgm %s", tmp.c_str());
  549.   return false;
  550. }
  552. bool
  553. connect_ndb_mgm(atrt_config& config){
  554.   for(size_t i = 0; i<config.m_processes.size(); i++){
  555.     atrt_process & proc = config.m_processes[i];
  556.     if((proc.m_type & atrt_process::NDB_MGM) != 0){
  557.       if(!connect_ndb_mgm(proc)){
  558. return false;
  559.       }
  560.     }
  561.   }
  562.   
  563.   return true;
  564. }
  566. static int remap(int i){
  567.   if(i == NDB_MGM_NODE_STATUS_NO_CONTACT) return NDB_MGM_NODE_STATUS_UNKNOWN;
  568.   if(i == NDB_MGM_NODE_STATUS_UNKNOWN) return NDB_MGM_NODE_STATUS_NO_CONTACT;
  569.   return i;
  570. }
  572. bool
  573. wait_ndb(atrt_config& config, int goal){
  575.   goal = remap(goal);
  578.   /**
  579.    * Get mgm handle for cluster
  580.    */
  581.   NdbMgmHandle handle = 0;
  582.   for(size_t i = 0; i<config.m_processes.size(); i++){
  583.     atrt_process & proc = config.m_processes[i];
  584.     if((proc.m_type & atrt_process::NDB_MGM) != 0){
  585.       handle = proc.m_ndb_mgm_handle;
  586.       break;
  587.     }
  588.   }
  589.   if(handle == 0){
  590.     g_logger.critical("Unable to find mgm handle");
  591.     return false;
  592.   }
  594.   if(goal == NDB_MGM_NODE_STATUS_STARTED){
  595.     /**
  596.      * 1) wait NOT_STARTED
  597.      * 2) send start
  598.      * 3) wait STARTED
  599.      */
  600.     if(!wait_ndb(config, NDB_MGM_NODE_STATUS_NOT_STARTED))
  601.       return false;
  602.     
  603.     ndb_mgm_start(handle, 0, 0);
  604.   }
  606.   struct ndb_mgm_cluster_state * state;
  608.   time_t now = time(0);
  609.   time_t end = now + 360;
  610.   int min = remap(NDB_MGM_NODE_STATUS_NO_CONTACT);
  611.   int min2 = goal;
  613.   while(now < end){
  614.     /**
  615.      * 1) retreive current state
  616.      */
  617.     state = 0;
  618.     do {
  619.       state = ndb_mgm_get_status(handle);
  620.       if(state == 0){
  621. const int err = ndb_mgm_get_latest_error(handle);
  622. g_logger.error("Unable to poll db state: %d %s %s",
  623.        ndb_mgm_get_latest_error(handle),
  624.        ndb_mgm_get_latest_error_msg(handle),
  625.        ndb_mgm_get_latest_error_desc(handle));
  626. if(err == NDB_MGM_SERVER_NOT_CONNECTED && connect_ndb_mgm(config)){
  627.   g_logger.error("Reconnected...");
  628.   continue;
  629. }
  630. return false;
  631.       }
  632.     } while(state == 0);
  633.     NdbAutoPtr<void> tmp(state);
  634.     
  635.     min2 = goal;
  636.     for(int i = 0; i<state->no_of_nodes; i++){
  637.       if(state->node_states[i].node_type == NDB_MGM_NODE_TYPE_NDB){
  638. const int s = remap(state->node_states[i].node_status);
  639. min2 = (min2 < s ? min2 : s );
  641. if(s < remap(NDB_MGM_NODE_STATUS_NO_CONTACT) || 
  642.    s > NDB_MGM_NODE_STATUS_STARTED){
  643.   g_logger.critical("Strange DB status during start: %d %d", i, min2);
  644.   return false;
  645. }
  647. if(min2 < min){
  648.   g_logger.critical("wait ndb failed node: %d %d %d %d", 
  649.     state->node_states[i].node_id, min, min2, goal);
  650. }
  651.       }
  652.     }
  653.     
  654.     if(min2 < min){
  655.       g_logger.critical("wait ndb failed %d %d %d", min, min2, goal);
  656.       return false;
  657.     }
  658.     
  659.     if(min2 == goal){
  660.       return true;
  661.       break;
  662.     }
  663.     
  664.     min = min2;
  665.     now = time(0);
  666.   }
  667.   
  668.   g_logger.critical("wait ndb timed out %d %d %d", min, min2, goal);
  669.   
  670.   return false;
  671. }
  673. bool
  674. start_process(atrt_process & proc){
  675.   if(proc.m_proc.m_id != -1){
  676.     g_logger.critical("starting already started process: %d", proc.m_index);
  677.     return false;
  678.   }
  679.   
  680.   BaseString path = proc.m_proc.m_cwd.substr(proc.m_host->m_base_dir.length()+BaseString("/run").length());
  681.   
  682.   BaseString tmp = g_setup_progname;
  683.   tmp.appfmt(" %s %s/%s/ %s",
  684.      proc.m_host->m_hostname.c_str(),
  685.      g_setup_path,
  686.      path.c_str(),
  687.      proc.m_proc.m_cwd.c_str());
  689.   const int r1 = system(tmp.c_str());
  690.   if(r1 != 0){
  691.     g_logger.critical("Failed to setup process");
  692.     return false;
  693.   }
  695.   {
  696.     Properties reply;
  697.     if(proc.m_host->m_cpcd->define_process(proc.m_proc, reply) != 0){
  698.       BaseString msg;
  699.       reply.get("errormessage", msg);
  700.       g_logger.error("Unable to define process: %s", msg.c_str());      
  701.       return false;
  702.     }
  703.   }
  704.   {
  705.     Properties reply;
  706.     if(proc.m_host->m_cpcd->start_process(proc.m_proc.m_id, reply) != 0){
  707.       BaseString msg;
  708.       reply.get("errormessage", msg);
  709.       g_logger.error("Unable to start process: %s", msg.c_str());
  710.       return false;
  711.     }
  712.   }
  713.   return true;
  714. }
  716. bool
  717. start_processes(atrt_config& config, int types){
  718.   for(size_t i = 0; i<config.m_processes.size(); i++){
  719.     atrt_process & proc = config.m_processes[i];
  720.     if((types & proc.m_type) != 0 && proc.m_proc.m_path != ""){
  721.       if(!start_process(proc)){
  722. return false;
  723.       }
  724.     }
  725.   }
  726.   return true;
  727. }
  729. bool
  730. stop_process(atrt_process & proc){
  731.   if(proc.m_proc.m_id == -1){
  732.     return true;
  733.   }
  735.   {
  736.     Properties reply;
  737.     if(proc.m_host->m_cpcd->stop_process(proc.m_proc.m_id, reply) != 0){
  738.       Uint32 status;
  739.       reply.get("status", &status);
  740.       if(status != 4){
  741. BaseString msg;
  742. reply.get("errormessage", msg);
  743. g_logger.error("Unable to stop process: %s(%d)", msg.c_str(), status);
  744. return false;
  745.       }
  746.     }
  747.   }
  748.   {
  749.     Properties reply;
  750.     if(proc.m_host->m_cpcd->undefine_process(proc.m_proc.m_id, reply) != 0){
  751.       BaseString msg;
  752.       reply.get("errormessage", msg);
  753.       g_logger.error("Unable to undefine process: %s", msg.c_str());      
  754.       return false;
  755.     }
  756.     proc.m_proc.m_id = -1;
  757.   }
  758.   return true;
  759. }
  761. bool
  762. stop_processes(atrt_config& config, int types){
  763.   for(size_t i = 0; i<config.m_processes.size(); i++){
  764.     atrt_process & proc = config.m_processes[i];
  765.     if((types & proc.m_type) != 0){
  766.       if(!stop_process(proc)){
  767. return false;
  768.       }
  769.     }
  770.   }
  771.   return true;
  772. }
  774. bool
  775. update_status(atrt_config& config, int){
  776.   
  777.   Vector<Vector<SimpleCpcClient::Process> > m_procs;
  778.   
  779.   Vector<SimpleCpcClient::Process> dummy;
  780.   m_procs.fill(config.m_hosts.size(), dummy);
  781.   for(size_t i = 0; i<config.m_hosts.size(); i++){
  782.     Properties p;
  783.     config.m_hosts[i].m_cpcd->list_processes(m_procs[i], p);
  784.   }
  786.   for(size_t i = 0; i<config.m_processes.size(); i++){
  787.     atrt_process & proc = config.m_processes[i];
  788.     if(proc.m_proc.m_id != -1){
  789.       Vector<SimpleCpcClient::Process> &h_procs= m_procs[proc.m_host->m_index];
  790.       bool found = false;
  791.       for(size_t j = 0; j<h_procs.size(); j++){
  792. if(proc.m_proc.m_id == h_procs[j].m_id){
  793.   found = true;
  794.   proc.m_proc.m_status = h_procs[j].m_status;
  795.   break;
  796. }
  797.       }
  798.       if(!found){
  799. g_logger.error("update_status: not found");
  800. g_logger.error("id: %d host: %s cmd: %s", 
  801.        proc.m_proc.m_id,
  802.        proc.m_hostname.c_str(),
  803.        proc.m_proc.m_path.c_str());
  804. for(size_t j = 0; j<h_procs.size(); j++){
  805.   g_logger.error("found: %d %s", h_procs[j].m_id, 
  806.  h_procs[j].m_path.c_str());
  807. }
  808. return false;
  809.       }
  810.     }
  811.   }
  812.   return true;
  813. }
  815. int
  816. is_running(atrt_config& config, int types){
  817.   int found = 0, running = 0;
  818.   for(size_t i = 0; i<config.m_processes.size(); i++){
  819.     atrt_process & proc = config.m_processes[i]; 
  820.     if((types & proc.m_type) != 0){
  821.       found++;
  822.       if(proc.m_proc.m_status == "running")
  823. running++;
  824.     }
  825.   }
  826.   
  827.   if(found == running)
  828.     return 2;
  829.   if(running == 0)
  830.     return 0;
  831.   return 1;
  832. }
  835. int
  836. insert(const char * pair, Properties & p){
  837.   BaseString tmp(pair);
  838.   
  839.   tmp.trim(" tnr");
  841.   Vector<BaseString> split;
  842.   tmp.split(split, ":=", 2);
  844.   if(split.size() != 2)
  845.     return -1;
  847.   p.put(split[0].trim().c_str(), split[1].trim().c_str()); 
  849.   return 0;
  850. }
  852. bool
  853. read_test_case(FILE * file, atrt_testcase& tc, int& line){
  855.   Properties p;
  856.   int elements = 0;
  857.   char buf[1024];
  858.   while(!feof(file)){
  859.     if(!fgets(buf, 1024, file))
  860.       break;
  862.     line++;
  863.     BaseString tmp = buf;
  864.     
  865.     if(tmp.length() > 0 && tmp.c_str()[0] == '#')
  866.       continue;
  867.     
  868.     if(insert(tmp.c_str(), p) != 0)
  869.       break;
  870.     
  871.     elements++;
  872.   }
  873.   
  874.   if(elements == 0){
  875.     if(file == stdin){
  876.       BaseString tmp(buf); 
  877.       tmp.trim(" tnr");
  878.       Vector<BaseString> split;
  879.       tmp.split(split, " ", 2);
  880.       tc.m_command = split[0];
  881.       if(split.size() == 2)
  882. tc.m_args = split[1];
  883.       else
  884. tc.m_args = "";
  885.       tc.m_max_time = 60000;
  886.       return true;
  887.     }
  888.     return false;
  889.   }
  891.   if(!p.get("cmd", tc.m_command)){
  892.     g_logger.critical("Invalid test file: cmd is missing near line: %d", line);
  893.     return false;
  894.   }
  895.   
  896.   if(!p.get("args", tc.m_args))
  897.     tc.m_args = "";
  899.   const char * mt = 0;
  900.   if(!p.get("max-time", &mt))
  901.     tc.m_max_time = 60000;
  902.   else
  903.     tc.m_max_time = atoi(mt);
  905.   if(p.get("type", &mt) && strcmp(mt, "bench") == 0)
  906.     tc.m_report= true;
  907.   else
  908.     tc.m_report= false;
  910.   if(p.get("run-all", &mt) && strcmp(mt, "yes") == 0)
  911.     tc.m_run_all= true;
  912.   else
  913.     tc.m_run_all= false;
  914.   
  915.   return true;
  916. }
  918. bool
  919. setup_test_case(atrt_config& config, const atrt_testcase& tc){
  920.   const int r1 = system(g_clear_progname);
  921.   if(r1 != 0){
  922.     g_logger.critical("Failed to clear result");
  923.     return false;
  924.   }
  925.   
  926.   size_t i = 0;
  927.   for(; i<config.m_processes.size(); i++){
  928.     atrt_process & proc = config.m_processes[i]; 
  929.     if(proc.m_type == atrt_process::NDB_API || proc.m_type == atrt_process::MYSQL_CLIENT){
  930.       proc.m_proc.m_path.assfmt("%s/bin/%s", proc.m_host->m_base_dir.c_str(),
  931. tc.m_command.c_str());
  932.       proc.m_proc.m_args.assign(tc.m_args);
  933.       if(!tc.m_run_all)
  934.         break;
  935.     }
  936.   }
  937.   for(i++; i<config.m_processes.size(); i++){
  938.     atrt_process & proc = config.m_processes[i]; 
  939.     if(proc.m_type == atrt_process::NDB_API || proc.m_type == atrt_process::MYSQL_CLIENT){
  940.       proc.m_proc.m_path.assign("");
  941.       proc.m_proc.m_args.assign("");
  942.     }
  943.   }
  944.   return true;
  945. }
  947. bool
  948. gather_result(atrt_config& config, int * result){
  949.   BaseString tmp = g_gather_progname;
  950.   for(size_t i = 0; i<config.m_processes.size(); i++){
  951.     atrt_process & proc = config.m_processes[i]; 
  952.     if(proc.m_proc.m_path != ""){
  953.       tmp.appfmt(" %s:%s", 
  954.  proc.m_hostname.c_str(),
  955.  proc.m_proc.m_cwd.c_str());
  956.     }
  957.   }
  958.   
  959.   const int r1 = system(tmp.c_str());
  960.   if(r1 != 0){
  961.     g_logger.critical("Failed to gather result");
  962.     return false;
  963.   }
  965.   const int r2 = system(g_analyze_progname);
  967.   if(r2 == -1 || r2 == (127 << 8)){
  968.     g_logger.critical("Failed to analyze results");
  969.     return false;
  970.   }
  971.   
  972.   * result = r2 ;
  973.   return true;
  974. }
  976. bool
  977. setup_hosts(atrt_config& config){
  978.   const int r1 = system(g_clear_progname);
  979.   if(r1 != 0){
  980.     g_logger.critical("Failed to clear result");
  981.     return false;
  982.   }
  984.   for(size_t i = 0; i<config.m_hosts.size(); i++){
  985.     BaseString tmp = g_setup_progname;
  986.     tmp.appfmt(" %s %s/ %s/run", 
  987.        config.m_hosts[i].m_hostname.c_str(),
  988.        g_setup_path,
  989.        config.m_hosts[i].m_base_dir.c_str());
  990.     
  991.     const int r1 = system(tmp.c_str());
  992.     if(r1 != 0){
  993.       g_logger.critical("Failed to setup %s",
  994. config.m_hosts[i].m_hostname.c_str());
  995.       return false;
  996.     }
  997.   }
  998.   return true;
  999. }
  1001. template class Vector<Vector<SimpleCpcClient::Process> >;
  1002. template class Vector<atrt_host>;
  1003. template class Vector<atrt_process>;