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

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

MySQL数据库

开发平台：

Visual C++

CpcClient.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 */
  17. #include <ndb_global.h>
  19. #include <NdbOut.hpp>
  20. #include <NdbTCP.h>
  21. #include "CpcClient.hpp"
  23. #define CPC_CMD(name, value, desc) 
  24.  { (name), 
  25.    0, 
  26.    ParserRow_t::Cmd, 
  27.    ParserRow_t::String, 
  28.    ParserRow_t::Optional, 
  29.    ParserRow_t::IgnoreMinMax, 
  30.    0, 0, 
  31.    0, 
  32.    (desc), 
  33.    (value) }
  35. #define CPC_ARG(name, type, opt, desc) 
  36.  { (name), 
  37.    0, 
  38.    ParserRow_t::Arg, 
  39.    ParserRow_t::type, 
  40.    ParserRow_t::opt, 
  41.    ParserRow_t::IgnoreMinMax, 
  42.    0, 0, 
  43.    0, 
  44.   (desc), 0 }
  46. #define CPC_END() 
  47.  { 0, 
  48.    0, 
  49.    ParserRow_t::Arg, 
  50.    ParserRow_t::Int, 
  51.    ParserRow_t::Optional, 
  52.    ParserRow_t::IgnoreMinMax, 
  53.    0, 0, 
  54.    0, 
  55.    0, 0 }
  57. #ifdef DEBUG_PRINT_PROPERTIES 
  58. static void printprop(const Properties &p) {
  59.   Properties::Iterator iter(&p);
  60.   const char *name;
  61.   while((name = iter.next()) != NULL) {
  62.     PropertiesType t;
  63.     Uint32 val_i;
  64.     BaseString val_s;
  66.     p.getTypeOf(name, &t);
  67.     switch(t) {
  68.     case PropertiesType_Uint32:
  69.       p.get(name, &val_i);
  70.       ndbout << name << " (Uint32): " << val_i << endl;
  71.       break;
  72.     case PropertiesType_char:
  73.       p.get(name, val_s);
  74.       ndbout << name << " (string): " << val_s << endl;
  75.       break;
  76.     default:
  77.       ndbout << "Unknown type " << t << endl;
  78.       break;
  79.     }
  80.   }
  81. }
  82. #endif
  84. void
  85. SimpleCpcClient::cmd_stop(char *arg) {
  86.   Properties p;
  87.   Vector<Process> proc_list;
  89.   list_processes(proc_list, p);
  90.   bool stopped = false;
  92.   for(size_t i = 0; i < proc_list.size(); i++) {
  93.     if(strcmp(proc_list[i].m_name.c_str(), arg) == 0) {
  94.       stopped = true;
  95.       Properties reply;
  96.       stop_process(proc_list[i].m_id, reply);
  98.       Uint32 status;
  99.       reply.get("status", &status);
  100.       if(status != 0) {
  101. BaseString msg;
  102. reply.get("errormessage", msg);
  103. ndbout << "Stop failed: " << msg << endl;
  104.       }
  105.     }
  106.   }
  107.   
  108.   if(!stopped)
  109.     ndbout << "No such process" << endl;
  110. }
  112. int
  113. SimpleCpcClient::stop_process(Uint32 id, Properties& reply){
  114.   const ParserRow_t stop_reply[] = {
  115.     CPC_CMD("stop process", NULL, ""),
  116.     CPC_ARG("status", Int, Mandatory, ""),
  117.     CPC_ARG("id", Int, Optional, ""),
  118.     CPC_ARG("errormessage", String, Optional, ""),
  119.     
  120.     CPC_END()
  121.   };
  123.   Properties args;
  124.   args.put("id", id);
  125.   
  126.   const Properties* ret = cpc_call("stop process", args, stop_reply);
  127.   if(ret == 0){
  128.     reply.put("status", (Uint32)0);
  129.     reply.put("errormessage", "unknown error");
  130.     return -1;
  131.   }
  133.   Uint32 status = 0;
  134.   ret->get("status", &status);
  135.   reply.put("status", status);
  136.   if(status != 0) {
  137.     BaseString msg;
  138.     ret->get("errormessage", msg);
  139.     reply.put("errormessage", msg.c_str());
  140.   }
  142.   return status;
  143. }
  145. void
  146. SimpleCpcClient::cmd_start(char *arg) {
  147.   Properties p;
  148.   Vector<Process> proc_list;
  149.   list_processes(proc_list, p);
  150.   bool startped = false;
  152.   for(size_t i = 0; i < proc_list.size(); i++) {
  153.     if(strcmp(proc_list[i].m_name.c_str(), arg) == 0) {
  154.       startped = true;
  156.       Properties reply;
  157.       start_process(proc_list[i].m_id, reply);
  159.       Uint32 status;
  160.       reply.get("status", &status);
  161.       if(status != 0) {
  162. BaseString msg;
  163. reply.get("errormessage", msg);
  164. ndbout << "Start failed: " << msg << endl;
  165.       }
  166.     }
  167.   }
  168.   
  169.   if(!startped)
  170.     ndbout << "No such process" << endl;
  171. }
  173. int
  174. SimpleCpcClient::start_process(Uint32 id, Properties& reply){
  175.   const ParserRow_t start_reply[] = {
  176.     CPC_CMD("start process", NULL, ""),
  177.     CPC_ARG("status", Int, Mandatory, ""),
  178.     CPC_ARG("id", Int, Optional, ""),
  179.     CPC_ARG("errormessage", String, Optional, ""),
  180.     
  181.     CPC_END()
  182.   };
  184.   Properties args;
  185.   args.put("id", id);
  186.   
  187.   const Properties* ret = cpc_call("start process", args, start_reply);
  188.   if(ret == 0){
  189.     reply.put("status", (Uint32)0);
  190.     reply.put("errormessage", "unknown error");
  191.     return -1;
  192.   }
  194.   Uint32 status = 0;
  195.   ret->get("status", &status);
  196.   reply.put("status", status);
  197.   if(status != 0) {
  198.     BaseString msg;
  199.     ret->get("errormessage", msg);
  200.     reply.put("errormessage", msg.c_str());
  201.   }
  203.   return status;
  204. }
  206. int
  207. SimpleCpcClient::undefine_process(Uint32 id, Properties& reply){
  208.   const ParserRow_t stop_reply[] = {
  209.     CPC_CMD("undefine process", NULL, ""),
  210.     CPC_ARG("status", Int, Mandatory, ""),
  211.     CPC_ARG("id", Int, Optional, ""),
  212.     CPC_ARG("errormessage", String, Optional, ""),
  213.     
  214.     CPC_END()
  215.   };
  217.   Properties args;
  218.   args.put("id", id);
  219.   
  220.   const Properties* ret = cpc_call("undefine process", args, stop_reply);
  221.   if(ret == 0){
  222.     reply.put("status", (Uint32)0);
  223.     reply.put("errormessage", "unknown error");
  224.     return -1;
  225.   }
  227.   Uint32 status = 0;
  228.   ret->get("status", &status);
  229.   reply.put("status", status);
  230.   if(status != 0) {
  231.     BaseString msg;
  232.     ret->get("errormessage", msg);
  233.     reply.put("errormessage", msg.c_str());
  234.   }
  236.   return status;
  237. }
  239. static void
  240. printproc(SimpleCpcClient::Process & p) {
  241.   ndbout.println("Name:                %s", p.m_name.c_str());
  242.   ndbout.println("Id:                  %d", p.m_id);
  243.   ndbout.println("Type:                %s", p.m_type.c_str());
  244.   ndbout.println("Group:               %s", p.m_group.c_str());
  245.   ndbout.println("Program path:        %s", p.m_path.c_str());
  246.   ndbout.println("Arguments:           %s", p.m_args.c_str());
  247.   ndbout.println("Environment:         %s", p.m_env.c_str());
  248.   ndbout.println("Working directory:   %s", p.m_cwd.c_str());
  249.   ndbout.println("Owner:               %s", p.m_owner.c_str());
  250.   ndbout.println("Runas:               %s", p.m_runas.c_str());
  251.   ndbout.println("Ulimit:              %s", p.m_ulimit.c_str());
  252.   ndbout.println("");
  253. }
  255. void
  256. SimpleCpcClient::cmd_list(char *arg) {
  257.   Properties p;
  258.   Vector<Process> proc_list;
  259.   list_processes(proc_list, p);
  261.   for(size_t i = 0; i < proc_list.size(); i++) {
  262.     printproc(proc_list[i]);
  263.   }
  264. }
  266. static int
  267. convert(const Properties & src, SimpleCpcClient::Process & dst){
  268.   bool b = true;
  269.   b &= src.get("id", (Uint32*)&dst.m_id);
  270.   b &= src.get("name",   dst.m_name);
  271.   b &= src.get("type",   dst.m_type);
  272.   b &= src.get("status", dst.m_status);
  273.   b &= src.get("owner",  dst.m_owner);
  274.   b &= src.get("group",  dst.m_group);
  275.   b &= src.get("path",   dst.m_path);
  276.   b &= src.get("args",   dst.m_args);
  277.   b &= src.get("env",    dst.m_env);
  278.   b &= src.get("cwd",    dst.m_cwd);
  279.   b &= src.get("runas",  dst.m_runas);
  281.   b &= src.get("stdin",  dst.m_stdin);
  282.   b &= src.get("stdout", dst.m_stdout);
  283.   b &= src.get("stderr", dst.m_stderr);
  284.   b &= src.get("ulimit", dst.m_ulimit);
  285.   b &= src.get("shutdown", dst.m_shutdown_options);
  287.   return b;
  288. }
  290. static int
  291. convert(const SimpleCpcClient::Process & src, Properties & dst ){
  292.   bool b = true;
  293.   //b &= dst.put("id",     (Uint32)src.m_id);
  294.   b &= dst.put("name",   src.m_name.c_str());
  295.   b &= dst.put("type",   src.m_type.c_str());
  296.   //b &= dst.put("status", src.m_status.c_str());
  297.   b &= dst.put("owner",  src.m_owner.c_str());
  298.   b &= dst.put("group",  src.m_group.c_str());
  299.   b &= dst.put("path",   src.m_path.c_str());
  300.   b &= dst.put("args",   src.m_args.c_str());
  301.   b &= dst.put("env",    src.m_env.c_str());
  302.   b &= dst.put("cwd",    src.m_cwd.c_str());
  303.   b &= dst.put("runas",  src.m_runas.c_str());
  305.   b &= dst.put("stdin",  src.m_stdin.c_str());
  306.   b &= dst.put("stdout", src.m_stdout.c_str());
  307.   b &= dst.put("stderr", src.m_stderr.c_str());
  308.   b &= dst.put("ulimit", src.m_ulimit.c_str());
  309.   b &= dst.put("shutdown", src.m_shutdown_options.c_str());
  310.   
  311.   return b;
  312. }
  314. int
  315. SimpleCpcClient::define_process(Process & p, Properties& reply){
  316.   const ParserRow_t define_reply[] = {
  317.     CPC_CMD("define process", NULL, ""),
  318.     CPC_ARG("status", Int, Mandatory, ""),
  319.     CPC_ARG("id", Int, Optional, ""),
  320.     CPC_ARG("errormessage", String, Optional, ""),
  321.     
  322.     CPC_END()
  323.   };
  325.   Properties args;
  326.   convert(p, args);
  328.   const Properties* ret = cpc_call("define process", args, define_reply);
  329.   if(ret == 0){
  330.     reply.put("status", (Uint32)0);
  331.     reply.put("errormessage", "unknown error");
  332.     return -1;
  333.   }
  335.   Uint32 status = 0;
  336.   ret->get("status", &status);
  337.   reply.put("status", status);
  338.   if(status != 0) {
  339.     BaseString msg;
  340.     ret->get("errormessage", msg);
  341.     reply.put("errormessage", msg.c_str());
  342.   }
  344.   Uint32 id;
  345.   if(!ret->get("id", &id)){
  346.     return -1;
  347.   }
  349.   p.m_id = id;
  350.   
  351.   return status;
  352. }
  354. int
  355. SimpleCpcClient::list_processes(Vector<Process> &procs, Properties& reply) {
  356.   int start, end, entry; 
  357.   const ParserRow_t list_reply[] = {
  358.     CPC_CMD("start processes", &start, ""),
  359.     CPC_CMD("end processes", &end, ""),
  361.     CPC_CMD("process", &entry, ""),
  362.     CPC_ARG("id",    Int,    Mandatory, "Id of process."),
  363.     CPC_ARG("name",  String, Mandatory, "Name of process"),
  364.     CPC_ARG("group", String, Mandatory, "Group of process"),
  365.     CPC_ARG("env",   String, Mandatory, "Environment variables for process"),
  366.     CPC_ARG("path",  String, Mandatory, "Path to binary"),
  367.     CPC_ARG("args",  String, Mandatory, "Arguments to process"),
  368.     CPC_ARG("type",  String, Mandatory, "Type of process"),
  369.     CPC_ARG("cwd",   String, Mandatory, "Working directory of process"),
  370.     CPC_ARG("owner", String, Mandatory, "Owner of process"),
  371.     CPC_ARG("status",String, Mandatory, "Status of process"),
  372.     CPC_ARG("runas", String, Mandatory, "Run as user"),
  373.     CPC_ARG("stdin", String, Mandatory, "Redirect stdin"),
  374.     CPC_ARG("stdout",String, Mandatory, "Redirect stdout"),
  375.     CPC_ARG("stderr",String, Mandatory, "Redirect stderr"),
  376.     CPC_ARG("ulimit",String, Mandatory, "ulimit"),    
  377.     CPC_ARG("shutdown",String, Mandatory, "shutdown"),    
  378.     
  379.     CPC_END()
  380.   };
  382.   reply.clear();
  384.   const Properties args;
  386.   cpc_send("list processes", args);
  388.   bool done = false;
  389.   while(!done) {
  390.     const Properties *proc;
  391.     void *p;
  392.     cpc_recv(list_reply, &proc, &p);
  394.     if(p == &start)
  395.     {
  396.       /* do nothing */
  397.     }
  398.     else if(p == &end)
  399.     {
  400.       done = true;
  401.     }
  402.     else if(p == &entry)
  403.     {
  404.       if(proc != NULL){
  405. Process p;
  406. convert(* proc, p);
  407. procs.push_back(p);
  408.       }
  409.     }
  410.     else
  411.     {
  412.       ndbout_c("internal error: %d", __LINE__);
  413.       return -1;
  414.     }
  415.   }
  416.   return 0;
  417. }
  419. void
  420. SimpleCpcClient::cmd_help(char *arg) {
  421.   ndbout
  422.     << "HELP Print help text" << endl
  423.     << "LIST List processes" << endl
  424.     << "START Start process" << endl
  425.     << "STOP Stop process" << endl;
  426. }
  428. SimpleCpcClient::SimpleCpcClient(const char *_host, int _port) {
  429.   host = strdup(_host);
  430.   port = _port;
  431.   cpc_sock = -1;
  432.   cpc_in = NULL;
  433.   cpc_out = NULL;
  434. }
  436. SimpleCpcClient::~SimpleCpcClient() {
  437.   if(host != NULL) {
  438.     free(host);
  439.     host = NULL;
  440.   }
  442.   port = 0;
  444.   if(cpc_sock == -1) {
  445.     close(cpc_sock);
  446.     cpc_sock = -1;
  447.   }
  449.   if(cpc_in != NULL)
  450.     delete cpc_in;
  452.   if(cpc_out != NULL)
  453.     delete cpc_out;
  454. }
  456. int
  457. SimpleCpcClient::connect() {
  458.   struct sockaddr_in sa;
  459.   struct hostent *hp;
  461.   /* Create socket */
  462.   cpc_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  463.   if(cpc_sock < 0)
  464.     return -1;
  466.   /* Connect socket */
  467.   sa.sin_family = AF_INET;
  468.   hp = gethostbyname(host);
  469.   if(hp == NULL) {
  470.     errno = ENOENT;
  471.     return -1;
  472.   }
  474.   memcpy(&sa.sin_addr, hp->h_addr, hp->h_length);
  475.   sa.sin_port = htons(port);
  476.   if (::connect(cpc_sock, (struct sockaddr*) &sa, sizeof(sa)) < 0)
  477.     return -1;
  479.   cpc_in = new SocketInputStream(cpc_sock, 60000);
  480.   cpc_out = new SocketOutputStream(cpc_sock);
  481.   
  482.   return 0;
  483. }
  485. int
  486. SimpleCpcClient::cpc_send(const char *cmd,
  487.   const Properties &args) {
  488.   
  489.   cpc_out->println(cmd);
  491.   Properties::Iterator iter(&args);
  492.   const char *name;
  493.   while((name = iter.next()) != NULL) {
  494.     PropertiesType t;
  495.     Uint32 val_i;
  496.     BaseString val_s;
  498.     args.getTypeOf(name, &t);
  499.     switch(t) {
  500.     case PropertiesType_Uint32:
  501.       args.get(name, &val_i);
  502.       cpc_out->println("%s: %d", name, val_i);
  503.       break;
  504.     case PropertiesType_char:
  505.       args.get(name, val_s);
  506.       cpc_out->println("%s: %s", name, val_s.c_str());
  507.       break;
  508.     default:
  509.       /* Silently ignore */
  510.       break;
  511.     }
  512.   }
  513.   cpc_out->println("");
  515.   return 0;
  516. }
  518. /**
  519.  * Receive a response from the CPCD. The argument reply will point
  520.  * to a Properties object describing the reply. Note that the caller
  521.  * is responsible for deleting the Properties object returned.
  522.  */
  523. SimpleCpcClient::Parser_t::ParserStatus
  524. SimpleCpcClient::cpc_recv(const ParserRow_t *syntax,
  525.   const Properties **reply,
  526.   void **user_value) {
  527.   Parser_t::Context ctx;
  528.   ParserDummy session(cpc_sock);
  529.   Parser_t parser(syntax, *cpc_in, true, true, true);
  530.   *reply = parser.parse(ctx, session);
  531.   if(user_value != NULL)
  532.     *user_value = ctx.m_currentCmd->user_value;
  533.   return ctx.m_status;
  534. }
  536. const Properties *
  537. SimpleCpcClient::cpc_call(const char *cmd,
  538.   const Properties &args,
  539.   const ParserRow_t *reply_syntax) {
  540.   cpc_send(cmd, args);
  542. #if 0
  543.   Parser_t::Context ctx;
  544.   ParserDummy session(cpc_sock);
  545.   Parser_t parser(reply_syntax, *cpc_in, true, true, true);
  546.   const Properties *ret = parser.parse(ctx, session);
  547.   return ret;
  548. #endif
  549.   const Properties *ret;
  550.   cpc_recv(reply_syntax, &ret);
  551.   return ret;
  552. }
  555. SimpleCpcClient::ParserDummy::ParserDummy(NDB_SOCKET_TYPE sock)
  556.   : SocketServer::Session(sock) {
  557. }
  558.  
  559. template class Vector<SimpleCpcClient::Process>; 
  560. template class Vector<ParserRow<SimpleCpcClient::ParserDummy> const*>;