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

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

MySQL数据库

开发平台：

Visual C++

ConfigInfo.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>
  18. #include <ndb_opt_defaults.h>
  20. #include <NdbTCP.h>
  21. #include "ConfigInfo.hpp"
  22. #include <mgmapi_config_parameters.h>
  23. #include <ndb_limits.h>
  24. #include "InitConfigFileParser.hpp"
  25. #include <m_string.h>
  27. extern my_bool opt_ndb_shm;
  28. extern my_bool opt_core;
  30. #define MAX_LINE_LENGTH 255
  31. #define KEY_INTERNAL 0
  32. #define MAX_INT_RNIL 0xfffffeff
  34. #define _STR_VALUE(x) #x
  35. #define STR_VALUE(x) _STR_VALUE(x)
  37. /****************************************************************************
  38.  * Section names
  39.  ****************************************************************************/
  41. #define DB_TOKEN_PRINT  "ndbd(DB)"
  42. #define MGM_TOKEN_PRINT "ndb_mgmd(MGM)"
  43. #define API_TOKEN_PRINT "mysqld(API)"
  45. #define DB_TOKEN "DB"
  46. #define MGM_TOKEN "MGM"
  47. #define API_TOKEN "API"
  49. const ConfigInfo::AliasPair
  50. ConfigInfo::m_sectionNameAliases[]={
  51.   {API_TOKEN, "MYSQLD"},
  52.   {DB_TOKEN,  "NDBD"},
  53.   {MGM_TOKEN, "NDB_MGMD"},
  54.   {0, 0}
  55. };
  57. const char* 
  58. ConfigInfo::m_sectionNames[]={
  59.   "SYSTEM",
  60.   "EXTERNAL SYSTEM",
  61.   "COMPUTER",
  63.   DB_TOKEN,
  64.   MGM_TOKEN,
  65.   API_TOKEN,
  67.   "TCP",
  68.   "SCI",
  69.   "SHM",
  70.   "OSE"
  71. };
  72. const int ConfigInfo::m_noOfSectionNames = 
  73. sizeof(m_sectionNames)/sizeof(char*);
  76. /****************************************************************************
  77.  * Section Rules declarations
  78.  ****************************************************************************/
  79. static bool transformComputer(InitConfigFileParser::Context & ctx, const char *);
  80. static bool transformSystem(InitConfigFileParser::Context & ctx, const char *);
  81. static bool transformExternalSystem(InitConfigFileParser::Context & ctx, const char *);
  82. static bool transformNode(InitConfigFileParser::Context & ctx, const char *);
  83. static bool transformExtNode(InitConfigFileParser::Context & ctx, const char *);
  84. static bool checkConnectionSupport(InitConfigFileParser::Context & ctx, const char *);
  85. static bool transformConnection(InitConfigFileParser::Context & ctx, const char *);
  86. static bool applyDefaultValues(InitConfigFileParser::Context & ctx, const char *);
  87. static bool checkMandatory(InitConfigFileParser::Context & ctx, const char *);
  88. static bool fixPortNumber(InitConfigFileParser::Context & ctx, const char *);
  89. static bool fixShmKey(InitConfigFileParser::Context & ctx, const char *);
  90. static bool checkDbConstraints(InitConfigFileParser::Context & ctx, const char *);
  91. static bool checkConnectionConstraints(InitConfigFileParser::Context &, const char *);
  92. static bool checkTCPConstraints(InitConfigFileParser::Context &, const char *);
  93. static bool fixNodeHostname(InitConfigFileParser::Context & ctx, const char * data);
  94. static bool fixHostname(InitConfigFileParser::Context & ctx, const char * data);
  95. static bool fixNodeId(InitConfigFileParser::Context & ctx, const char * data);
  96. static bool fixExtConnection(InitConfigFileParser::Context & ctx, const char * data);
  97. static bool fixDepricated(InitConfigFileParser::Context & ctx, const char *);
  98. static bool saveInConfigValues(InitConfigFileParser::Context & ctx, const char *);
  99. static bool fixFileSystemPath(InitConfigFileParser::Context & ctx, const char * data);
  100. static bool fixBackupDataDir(InitConfigFileParser::Context & ctx, const char * data);
  101. static bool fixShmUniqueId(InitConfigFileParser::Context & ctx, const char * data);
  102. static bool checkLocalhostHostnameMix(InitConfigFileParser::Context & ctx, const char * data);
  104. const ConfigInfo::SectionRule 
  105. ConfigInfo::m_SectionRules[] = {
  106.   { "SYSTEM", transformSystem, 0 },
  107.   { "EXTERNAL SYSTEM", transformExternalSystem, 0 },
  108.   { "COMPUTER", transformComputer, 0 },
  110.   { DB_TOKEN,   transformNode, 0 },
  111.   { API_TOKEN,  transformNode, 0 },
  112.   { MGM_TOKEN,  transformNode, 0 },
  114.   { MGM_TOKEN,  fixShmUniqueId, 0 },
  116.   { "TCP",  checkConnectionSupport, 0 },
  117.   { "SHM",  checkConnectionSupport, 0 },
  118.   { "SCI",  checkConnectionSupport, 0 },
  119.   { "OSE",  checkConnectionSupport, 0 },
  121.   { "TCP",  transformConnection, 0 },
  122.   { "SHM",  transformConnection, 0 },
  123.   { "SCI",  transformConnection, 0 },
  124.   { "OSE",  transformConnection, 0 },
  126.   { DB_TOKEN,   fixNodeHostname, 0 },
  127.   { API_TOKEN,  fixNodeHostname, 0 },
  128.   { MGM_TOKEN,  fixNodeHostname, 0 },
  130.   { "TCP",  fixNodeId, "NodeId1" },
  131.   { "TCP",  fixNodeId, "NodeId2" },
  132.   { "SHM",  fixNodeId, "NodeId1" },
  133.   { "SHM",  fixNodeId, "NodeId2" },
  134.   { "SCI",  fixNodeId, "NodeId1" },
  135.   { "SCI",  fixNodeId, "NodeId2" },
  136.   { "OSE",  fixNodeId, "NodeId1" },
  137.   { "OSE",  fixNodeId, "NodeId2" },
  138.   
  139.   { "TCP",  fixHostname, "HostName1" },
  140.   { "TCP",  fixHostname, "HostName2" },
  141.   { "SHM",  fixHostname, "HostName1" },
  142.   { "SHM",  fixHostname, "HostName2" },
  143.   { "SCI",  fixHostname, "HostName1" },
  144.   { "SCI",  fixHostname, "HostName2" },
  145.   { "SHM",  fixHostname, "HostName1" },
  146.   { "SHM",  fixHostname, "HostName2" },
  147.   { "OSE",  fixHostname, "HostName1" },
  148.   { "OSE",  fixHostname, "HostName2" },
  150.   { "TCP",  fixPortNumber, 0 }, // has to come after fixHostName
  151.   { "SHM",  fixPortNumber, 0 }, // has to come after fixHostName
  152.   { "SCI",  fixPortNumber, 0 }, // has to come after fixHostName
  153.   { "SHM",  fixShmKey, 0 },
  155.   /**
  156.    * fixExtConnection must be after fixNodeId
  157.    */
  158.   { "TCP",  fixExtConnection, 0 },
  159.   { "SHM",  fixExtConnection, 0 },
  160.   { "SCI",  fixExtConnection, 0 },
  161.   { "OSE",  fixExtConnection, 0 },
  162.   
  163.   { "*",    applyDefaultValues, "user" },
  164.   { "*",    fixDepricated, 0 },
  165.   { "*",    applyDefaultValues, "system" },
  167.   { DB_TOKEN,   checkLocalhostHostnameMix, 0 },
  168.   { API_TOKEN,  checkLocalhostHostnameMix, 0 },
  169.   { MGM_TOKEN,  checkLocalhostHostnameMix, 0 },
  171.   { DB_TOKEN,   fixFileSystemPath, 0 },
  172.   { DB_TOKEN,   fixBackupDataDir, 0 },
  174.   { DB_TOKEN,   checkDbConstraints, 0 },
  176.   /**
  177.    * checkConnectionConstraints must be after fixExtConnection
  178.    */
  179.   { "TCP",  checkConnectionConstraints, 0 },
  180.   { "SHM",  checkConnectionConstraints, 0 },
  181.   { "SCI",  checkConnectionConstraints, 0 },
  182.   { "OSE",  checkConnectionConstraints, 0 },
  184.   { "TCP",  checkTCPConstraints, "HostName1" },
  185.   { "TCP",  checkTCPConstraints, "HostName2" },
  186.   { "SCI",  checkTCPConstraints, "HostName1" },
  187.   { "SCI",  checkTCPConstraints, "HostName2" },
  188.   { "SHM",  checkTCPConstraints, "HostName1" },
  189.   { "SHM",  checkTCPConstraints, "HostName2" },
  190.   
  191.   { "*",    checkMandatory, 0 },
  192.   
  193.   { DB_TOKEN,   saveInConfigValues, 0 },
  194.   { API_TOKEN,  saveInConfigValues, 0 },
  195.   { MGM_TOKEN,  saveInConfigValues, 0 },
  197.   { "TCP",  saveInConfigValues, 0 },
  198.   { "SHM",  saveInConfigValues, 0 },
  199.   { "SCI",  saveInConfigValues, 0 },
  200.   { "OSE",  saveInConfigValues, 0 }
  201. };
  202. const int ConfigInfo::m_NoOfRules = sizeof(m_SectionRules)/sizeof(SectionRule);
  204. /****************************************************************************
  205.  * Config Rules declarations
  206.  ****************************************************************************/
  207. static bool sanity_checks(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  208.   struct InitConfigFileParser::Context &ctx, 
  209.   const char * rule_data);
  210. static bool add_node_connections(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  211.  struct InitConfigFileParser::Context &ctx, 
  212.  const char * rule_data);
  213. static bool set_connection_priorities(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  214.  struct InitConfigFileParser::Context &ctx, 
  215.  const char * rule_data);
  216. static bool add_server_ports(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  217.       struct InitConfigFileParser::Context &ctx, 
  218.       const char * rule_data);
  219. static bool check_node_vs_replicas(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  220.     struct InitConfigFileParser::Context &ctx, 
  221.     const char * rule_data);
  223. const ConfigInfo::ConfigRule 
  224. ConfigInfo::m_ConfigRules[] = {
  225.   { sanity_checks, 0 },
  226.   { add_node_connections, 0 },
  227.   { set_connection_priorities, 0 },
  228.   { add_server_ports, 0 },
  229.   { check_node_vs_replicas, 0 },
  230.   { 0, 0 }
  231. };
  232.   
  233. struct DepricationTransform {
  234.   const char * m_section;
  235.   const char * m_oldName;
  236.   const char * m_newName;
  237.   double m_add;
  238.   double m_mul;
  239. };
  241. static
  242. const DepricationTransform f_deprication[] = {
  243.   { DB_TOKEN, "Discless", "Diskless", 0, 1 },
  244.   { 0, 0, 0, 0, 0}
  245. };
  247. /**
  248.  * The default constructors create objects with suitable values for the
  249.  * configuration parameters. 
  250.  *
  251.  * Some are however given the value MANDATORY which means that the value
  252.  * must be specified in the configuration file. 
  253.  *
  254.  * Min and max values are also given for some parameters.
  255.  * - Attr1:  Name in file (initial config file)
  256.  * - Attr2:  Name in prop (properties object)
  257.  * - Attr3:  Name of Section (in init config file)
  258.  * - Attr4:  Updateable
  259.  * - Attr5:  Type of parameter (INT or BOOL)
  260.  * - Attr6:  Default Value (number only)
  261.  * - Attr7:  Min value
  262.  * - Attr8:  Max value
  263.  * 
  264.  * Parameter constraints are coded in file Config.cpp.
  265.  *
  266.  * *******************************************************************
  267.  * Parameters used under development should be marked "NOTIMPLEMENTED"
  268.  * *******************************************************************
  269.  */
  271. const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
  273.   /****************************************************************************
  274.    * COMPUTER
  275.    ***************************************************************************/
  276.   {
  277.     KEY_INTERNAL,
  278.     "COMPUTER",
  279.     "COMPUTER",
  280.     "Computer section",
  281.     ConfigInfo::CI_INTERNAL,
  282.     false,
  283.     ConfigInfo::CI_SECTION,
  284.     0,
  285.     0, 0 },
  286.   
  287.   {
  288.     KEY_INTERNAL,
  289.     "Id",
  290.     "COMPUTER",
  291.     "Name of computer",
  292.     ConfigInfo::CI_USED,
  293.     false,
  294.     ConfigInfo::CI_STRING,
  295.     MANDATORY,
  296.     0, 0 },
  298.   {
  299.     KEY_INTERNAL,
  300.     "HostName",
  301.     "COMPUTER",
  302.     "Hostname of computer (e.g. mysql.com)",
  303.     ConfigInfo::CI_USED,
  304.     false,
  305.     ConfigInfo::CI_STRING,
  306.     MANDATORY,
  307.     0, 0 },
  309.   {
  310.     KEY_INTERNAL,
  311.     "ByteOrder",
  312.     "COMPUTER",
  313.     0,
  314.     ConfigInfo::CI_DEPRICATED,
  315.     false,
  316.     ConfigInfo::CI_STRING,
  317.     UNDEFINED,
  318.     0,
  319.     0 },
  320.   
  321.   /****************************************************************************
  322.    * SYSTEM
  323.    ***************************************************************************/
  324.   {
  325.     CFG_SECTION_SYSTEM,
  326.     "SYSTEM",
  327.     "SYSTEM",
  328.     "System section",
  329.     ConfigInfo::CI_USED,
  330.     false,
  331.     ConfigInfo::CI_SECTION,
  332.     (const char *)CFG_SECTION_SYSTEM,
  333.     0, 0 },
  335.   {
  336.     CFG_SYS_NAME,
  337.     "Name",
  338.     "SYSTEM",
  339.     "Name of system (NDB Cluster)",
  340.     ConfigInfo::CI_USED,
  341.     false,
  342.     ConfigInfo::CI_STRING,
  343.     MANDATORY,
  344.     0, 0 },
  345.   
  346.   {
  347.     CFG_SYS_PRIMARY_MGM_NODE,
  348.     "PrimaryMGMNode",
  349.     "SYSTEM",
  350.     "Node id of Primary "MGM_TOKEN_PRINT" node",
  351.     ConfigInfo::CI_USED,
  352.     false,
  353.     ConfigInfo::CI_INT,
  354.     "0",
  355.     "0",
  356.     STR_VALUE(MAX_INT_RNIL) },
  358.   {
  359.     CFG_SYS_CONFIG_GENERATION,
  360.     "ConfigGenerationNumber",
  361.     "SYSTEM",
  362.     "Configuration generation number",
  363.     ConfigInfo::CI_USED,
  364.     false,
  365.     ConfigInfo::CI_INT,
  366.     "0",
  367.     "0",
  368.     STR_VALUE(MAX_INT_RNIL) },
  370.   /***************************************************************************
  371.    * DB
  372.    ***************************************************************************/
  373.   {
  374.     CFG_SECTION_NODE,
  375.     DB_TOKEN,
  376.     DB_TOKEN,
  377.     "Node section",
  378.     ConfigInfo::CI_USED,
  379.     false,
  380.     ConfigInfo::CI_SECTION,
  381.     (const char *)NODE_TYPE_DB, 
  382.     0, 0
  383.   },
  385.   {
  386.     CFG_NODE_HOST,
  387.     "HostName",
  388.     DB_TOKEN,
  389.     "Name of computer for this node",
  390.     ConfigInfo::CI_INTERNAL,
  391.     false,
  392.     ConfigInfo::CI_STRING,
  393.     "localhost",
  394.     0, 0 },
  396.   {
  397.     CFG_NODE_SYSTEM,
  398.     "System",
  399.     DB_TOKEN,
  400.     "Name of system for this node",
  401.     ConfigInfo::CI_INTERNAL,
  402.     false,
  403.     ConfigInfo::CI_STRING,
  404.     UNDEFINED,
  405.     0, 0 },
  407.   {
  408.     CFG_NODE_ID,
  409.     "Id",
  410.     DB_TOKEN,
  411.     "Number identifying the database node ("DB_TOKEN_PRINT")",
  412.     ConfigInfo::CI_USED,
  413.     false,
  414.     ConfigInfo::CI_INT,
  415.     MANDATORY,
  416.     "1",
  417.     STR_VALUE(MAX_NODES) },
  419.   {
  420.     KEY_INTERNAL,
  421.     "ServerPort",
  422.     DB_TOKEN,
  423.     "Port used to setup transporter",
  424.     ConfigInfo::CI_USED,
  425.     false,
  426.     ConfigInfo::CI_INT,
  427.     UNDEFINED,
  428.     "1",
  429.     STR_VALUE(MAX_INT_RNIL) },
  431.   {
  432.     CFG_DB_NO_REPLICAS,
  433.     "NoOfReplicas",
  434.     DB_TOKEN,
  435.     "Number of copies of all data in the database (1-4)",
  436.     ConfigInfo::CI_USED,
  437.     false,
  438.     ConfigInfo::CI_INT,
  439.     MANDATORY,
  440.     "1",
  441.     "4" },
  443.   {
  444.     CFG_DB_NO_ATTRIBUTES,
  445.     "MaxNoOfAttributes",
  446.     DB_TOKEN,
  447.     "Total number of attributes stored in database. I.e. sum over all tables",
  448.     ConfigInfo::CI_USED,
  449.     false,
  450.     ConfigInfo::CI_INT,
  451.     "1000",
  452.     "32",
  453.     STR_VALUE(MAX_INT_RNIL) },
  454.   
  455.   {
  456.     CFG_DB_NO_TABLES,
  457.     "MaxNoOfTables",
  458.     DB_TOKEN,
  459.     "Total number of tables stored in the database",
  460.     ConfigInfo::CI_USED,
  461.     false,
  462.     ConfigInfo::CI_INT,
  463.     "128",
  464.     "8",
  465.     STR_VALUE(MAX_INT_RNIL) },
  466.   
  467.   {
  468.     CFG_DB_NO_ORDERED_INDEXES,
  469.     "MaxNoOfOrderedIndexes",
  470.     DB_TOKEN,
  471.     "Total number of ordered indexes that can be defined in the system",
  472.     ConfigInfo::CI_USED,
  473.     false,
  474.     ConfigInfo::CI_INT,
  475.     "128",
  476.     "0",
  477.     STR_VALUE(MAX_INT_RNIL) },
  479.   {
  480.     CFG_DB_NO_UNIQUE_HASH_INDEXES,
  481.     "MaxNoOfUniqueHashIndexes",
  482.     DB_TOKEN,
  483.     "Total number of unique hash indexes that can be defined in the system",
  484.     ConfigInfo::CI_USED,
  485.     false,
  486.     ConfigInfo::CI_INT,
  487.     "64",
  488.     "0",
  489.     STR_VALUE(MAX_INT_RNIL) },
  491.   {
  492.     CFG_DB_NO_INDEXES,
  493.     "MaxNoOfIndexes",
  494.     DB_TOKEN,
  495.     "Total number of indexes that can be defined in the system",
  496.     ConfigInfo::CI_DEPRICATED,
  497.     false,
  498.     ConfigInfo::CI_INT,
  499.     "128",
  500.     "0",
  501.     STR_VALUE(MAX_INT_RNIL) },
  503.   {
  504.     CFG_DB_NO_INDEX_OPS,
  505.     "MaxNoOfConcurrentIndexOperations",
  506.     DB_TOKEN,
  507.     "Total number of index operations that can execute simultaneously on one "DB_TOKEN_PRINT" node",
  508.     ConfigInfo::CI_USED,
  509.     false,
  510.     ConfigInfo::CI_INT,
  511.     "8K",
  512.     "0",
  513.     STR_VALUE(MAX_INT_RNIL) 
  514.    },
  516.   {
  517.     CFG_DB_NO_TRIGGERS,
  518.     "MaxNoOfTriggers",
  519.     DB_TOKEN,
  520.     "Total number of triggers that can be defined in the system",
  521.     ConfigInfo::CI_USED,
  522.     false,
  523.     ConfigInfo::CI_INT,
  524.     "768",
  525.     "0",
  526.     STR_VALUE(MAX_INT_RNIL) },
  528.   {
  529.     CFG_DB_NO_TRIGGER_OPS,
  530.     "MaxNoOfFiredTriggers",
  531.     DB_TOKEN,
  532.     "Total number of triggers that can fire simultaneously in one "DB_TOKEN_PRINT" node",
  533.     ConfigInfo::CI_USED,
  534.     false,
  535.     ConfigInfo::CI_INT,
  536.     "4000",
  537.     "0",
  538.     STR_VALUE(MAX_INT_RNIL) },
  540.   {
  541.     KEY_INTERNAL,
  542.     "ExecuteOnComputer",
  543.     DB_TOKEN,
  544.     "String referencing an earlier defined COMPUTER",
  545.     ConfigInfo::CI_USED,
  546.     false,
  547.     ConfigInfo::CI_STRING,
  548.     UNDEFINED,
  549.     0, 0 },
  550.   
  551.   {
  552.     CFG_DB_NO_SAVE_MSGS,
  553.     "MaxNoOfSavedMessages",
  554.     DB_TOKEN,
  555.     "Max number of error messages in error log and max number of trace files",
  556.     ConfigInfo::CI_USED,
  557.     true,
  558.     ConfigInfo::CI_INT,
  559.     "25",
  560.     "0",
  561.     STR_VALUE(MAX_INT_RNIL) },
  563.   {
  564.     CFG_DB_MEMLOCK,
  565.     "LockPagesInMainMemory",
  566.     DB_TOKEN,
  567.     "If set to yes, then NDB Cluster data will not be swapped out to disk",
  568.     ConfigInfo::CI_USED,
  569.     true,
  570.     ConfigInfo::CI_BOOL,
  571.     "false",
  572.     "false",
  573.     "true" },
  575.   {
  576.     CFG_DB_WATCHDOG_INTERVAL,
  577.     "TimeBetweenWatchDogCheck",
  578.     DB_TOKEN,
  579.     "Time between execution checks inside a database node",
  580.     ConfigInfo::CI_USED,
  581.     true,
  582.     ConfigInfo::CI_INT,
  583.     "6000",
  584.     "70",
  585.     STR_VALUE(MAX_INT_RNIL) },
  587.   {
  588.     CFG_DB_STOP_ON_ERROR,
  589.     "StopOnError",
  590.     DB_TOKEN,
  591.     "If set to N, "DB_TOKEN_PRINT" automatically restarts/recovers in case of node failure",
  592.     ConfigInfo::CI_USED,
  593.     true,
  594.     ConfigInfo::CI_BOOL,
  595.     "true",
  596.     "false",
  597.     "true" },
  599.   { 
  600.     CFG_DB_STOP_ON_ERROR_INSERT,
  601.     "RestartOnErrorInsert",
  602.     DB_TOKEN,
  603.     "See src/kernel/vm/Emulator.hpp NdbRestartType for details",
  604.     ConfigInfo::CI_INTERNAL,
  605.     true,
  606.     ConfigInfo::CI_INT,
  607.     "2",
  608.     "0",
  609.     "4" },
  610.   
  611.   {
  612.     CFG_DB_NO_OPS,
  613.     "MaxNoOfConcurrentOperations",
  614.     DB_TOKEN,
  615.     "Max number of operation records in transaction coordinator",
  616.     ConfigInfo::CI_USED,
  617.     false,
  618.     ConfigInfo::CI_INT,
  619.     "32k",
  620.     "32",
  621.     STR_VALUE(MAX_INT_RNIL) },
  623.   {
  624.     CFG_DB_NO_LOCAL_OPS,
  625.     "MaxNoOfLocalOperations",
  626.     DB_TOKEN,
  627.     "Max number of operation records defined in the local storage node",
  628.     ConfigInfo::CI_USED,
  629.     false,
  630.     ConfigInfo::CI_INT,
  631.     UNDEFINED,
  632.     "32",
  633.     STR_VALUE(MAX_INT_RNIL) },
  635.   {
  636.     CFG_DB_NO_LOCAL_SCANS,
  637.     "MaxNoOfLocalScans",
  638.     DB_TOKEN,
  639.     "Max number of fragment scans in parallel in the local storage node",
  640.     ConfigInfo::CI_USED,
  641.     false,
  642.     ConfigInfo::CI_INT,
  643.     UNDEFINED,
  644.     "32",
  645.     STR_VALUE(MAX_INT_RNIL) },
  647.   {
  648.     CFG_DB_BATCH_SIZE,
  649.     "BatchSizePerLocalScan",
  650.     DB_TOKEN,
  651.     "Used to calculate the number of lock records for scan with hold lock",
  652.     ConfigInfo::CI_USED,
  653.     false,
  654.     ConfigInfo::CI_INT,
  655.     STR_VALUE(DEF_BATCH_SIZE),
  656.     "1",
  657.     STR_VALUE(MAX_PARALLEL_OP_PER_SCAN) },
  659.   {
  660.     CFG_DB_NO_TRANSACTIONS,
  661.     "MaxNoOfConcurrentTransactions",
  662.     DB_TOKEN,
  663.     "Max number of transaction executing concurrently on the "DB_TOKEN_PRINT" node",
  664.     ConfigInfo::CI_USED,
  665.     false,
  666.     ConfigInfo::CI_INT,
  667.     "4096",
  668.     "32",
  669.     STR_VALUE(MAX_INT_RNIL) },
  671.   {
  672.     CFG_DB_NO_SCANS,
  673.     "MaxNoOfConcurrentScans",
  674.     DB_TOKEN,
  675.     "Max number of scans executing concurrently on the "DB_TOKEN_PRINT" node",
  676.     ConfigInfo::CI_USED,
  677.     false,
  678.     ConfigInfo::CI_INT,
  679.     "256",
  680.     "2",
  681.     "500" },
  683.   {
  684.     CFG_DB_TRANS_BUFFER_MEM,
  685.     "TransactionBufferMemory",
  686.     DB_TOKEN,
  687.     "Dynamic buffer space (in bytes) for key and attribute data allocated for each "DB_TOKEN_PRINT" node",
  688.     ConfigInfo::CI_USED,
  689.     false,
  690.     ConfigInfo::CI_INT,
  691.     "1M",
  692.     "1K",
  693.     STR_VALUE(MAX_INT_RNIL) },
  694.  
  695.   {
  696.     CFG_DB_INDEX_MEM,
  697.     "IndexMemory",
  698.     DB_TOKEN,
  699.     "Number bytes on each "DB_TOKEN_PRINT" node allocated for storing indexes",
  700.     ConfigInfo::CI_USED,
  701.     false,
  702.     ConfigInfo::CI_INT64,
  703.     "18M",
  704.     "1M",
  705.     "1024G" },
  707.   {
  708.     CFG_DB_DATA_MEM,
  709.     "DataMemory",
  710.     DB_TOKEN,
  711.     "Number bytes on each "DB_TOKEN_PRINT" node allocated for storing data",
  712.     ConfigInfo::CI_USED,
  713.     false,
  714.     ConfigInfo::CI_INT64,
  715.     "80M",
  716.     "1M",
  717.     "1024G" },
  719.   {
  720.     CFG_DB_UNDO_INDEX_BUFFER,
  721.     "UndoIndexBuffer",
  722.     DB_TOKEN,
  723.     "Number bytes on each "DB_TOKEN_PRINT" node allocated for writing UNDO logs for index part",
  724.     ConfigInfo::CI_USED,
  725.     false,
  726.     ConfigInfo::CI_INT,
  727.     "2M",
  728.     "1M",
  729.     STR_VALUE(MAX_INT_RNIL)},
  731.   {
  732.     CFG_DB_UNDO_DATA_BUFFER,
  733.     "UndoDataBuffer",
  734.     DB_TOKEN,
  735.     "Number bytes on each "DB_TOKEN_PRINT" node allocated for writing UNDO logs for data part",
  736.     ConfigInfo::CI_USED,
  737.     false,
  738.     ConfigInfo::CI_INT,
  739.     "16M",
  740.     "1M",
  741.     STR_VALUE(MAX_INT_RNIL)},
  743.   {
  744.     CFG_DB_REDO_BUFFER,
  745.     "RedoBuffer",
  746.     DB_TOKEN,
  747.     "Number bytes on each "DB_TOKEN_PRINT" node allocated for writing REDO logs",
  748.     ConfigInfo::CI_USED,
  749.     false,
  750.     ConfigInfo::CI_INT,
  751.     "8M",
  752.     "1M",
  753.     STR_VALUE(MAX_INT_RNIL)},
  755.   {
  756.     CFG_DB_LONG_SIGNAL_BUFFER,
  757.     "LongMessageBuffer",
  758.     DB_TOKEN,
  759.     "Number bytes on each "DB_TOKEN_PRINT" node allocated for internal long messages",
  760.     ConfigInfo::CI_USED,
  761.     false,
  762.     ConfigInfo::CI_INT,
  763.     "1M",
  764.     "512k",
  765.     STR_VALUE(MAX_INT_RNIL)},
  767.   {
  768.     CFG_DB_START_PARTIAL_TIMEOUT,
  769.     "StartPartialTimeout",
  770.     DB_TOKEN,
  771.     "Time to wait before trying to start wo/ all nodes. 0=Wait forever",
  772.     ConfigInfo::CI_USED,
  773.     true,
  774.     ConfigInfo::CI_INT,
  775.     "30000",
  776.     "0",
  777.     STR_VALUE(MAX_INT_RNIL) },
  779.   {
  780.     CFG_DB_START_PARTITION_TIMEOUT,
  781.     "StartPartitionedTimeout",
  782.     DB_TOKEN,
  783.     "Time to wait before trying to start partitioned. 0=Wait forever",
  784.     ConfigInfo::CI_USED,
  785.     true,
  786.     ConfigInfo::CI_INT,
  787.     "60000",
  788.     "0",
  789.     STR_VALUE(MAX_INT_RNIL) },
  790.   
  791.   {
  792.     CFG_DB_START_FAILURE_TIMEOUT,
  793.     "StartFailureTimeout",
  794.     DB_TOKEN,
  795.     "Time to wait before terminating. 0=Wait forever",
  796.     ConfigInfo::CI_USED,
  797.     true,
  798.     ConfigInfo::CI_INT,
  799.     "0",
  800.     "0",
  801.     STR_VALUE(MAX_INT_RNIL) },
  802.   
  803.   {
  804.     CFG_DB_HEARTBEAT_INTERVAL,
  805.     "HeartbeatIntervalDbDb",
  806.     DB_TOKEN,
  807.     "Time between "DB_TOKEN_PRINT"-"DB_TOKEN_PRINT" heartbeats. "DB_TOKEN_PRINT" considered dead after 3 missed HBs",
  808.     ConfigInfo::CI_USED,
  809.     true,
  810.     ConfigInfo::CI_INT,
  811.     "1500",
  812.     "10",
  813.     STR_VALUE(MAX_INT_RNIL) },
  815.   {
  816.     CFG_DB_API_HEARTBEAT_INTERVAL,
  817.     "HeartbeatIntervalDbApi",
  818.     DB_TOKEN,
  819.     "Time between "API_TOKEN_PRINT"-"DB_TOKEN_PRINT" heartbeats. "API_TOKEN_PRINT" connection closed after 3 missed HBs",
  820.     ConfigInfo::CI_USED,
  821.     true,
  822.     ConfigInfo::CI_INT,
  823.     "1500",
  824.     "100",
  825.     STR_VALUE(MAX_INT_RNIL) },
  827.   {
  828.     CFG_DB_LCP_INTERVAL,
  829.     "TimeBetweenLocalCheckpoints",
  830.     DB_TOKEN,
  831.     "Time between taking snapshots of the database (expressed in 2log of bytes)",
  832.     ConfigInfo::CI_USED,
  833.     true,
  834.     ConfigInfo::CI_INT,
  835.     "20",
  836.     "0",
  837.     "31" },
  839.   {
  840.     CFG_DB_GCP_INTERVAL,
  841.     "TimeBetweenGlobalCheckpoints",
  842.     DB_TOKEN,
  843.     "Time between doing group commit of transactions to disk",
  844.     ConfigInfo::CI_USED,
  845.     true,
  846.     ConfigInfo::CI_INT,
  847.     "2000",
  848.     "10",
  849.     "32000" },
  851.   {
  852.     CFG_DB_NO_REDOLOG_FILES,
  853.     "NoOfFragmentLogFiles",
  854.     DB_TOKEN,
  855.     "No of 16 Mbyte Redo log files in each of 4 file sets belonging to "DB_TOKEN_PRINT" node",
  856.     ConfigInfo::CI_USED,
  857.     false,
  858.     ConfigInfo::CI_INT,
  859.     "8",
  860.     "1",
  861.     STR_VALUE(MAX_INT_RNIL) },
  863.   {
  864.     CFG_DB_MAX_OPEN_FILES,
  865.     "MaxNoOfOpenFiles",
  866.     DB_TOKEN,
  867.     "Max number of files open per "DB_TOKEN_PRINT" node.(One thread is created per file)",
  868.     ConfigInfo::CI_USED,
  869.     false,
  870.     ConfigInfo::CI_INT,
  871.     "40",
  872.     "20",
  873.     STR_VALUE(MAX_INT_RNIL) },
  874.   
  875.   {
  876.     CFG_DB_TRANSACTION_CHECK_INTERVAL,
  877.     "TimeBetweenInactiveTransactionAbortCheck",
  878.     DB_TOKEN,
  879.     "Time between inactive transaction checks",
  880.     ConfigInfo::CI_USED,
  881.     true,
  882.     ConfigInfo::CI_INT,
  883.     "1000",
  884.     "1000",
  885.     STR_VALUE(MAX_INT_RNIL) },
  886.   
  887.   {
  888.     CFG_DB_TRANSACTION_INACTIVE_TIMEOUT,
  889.     "TransactionInactiveTimeout",
  890.     DB_TOKEN,
  891.     "Time application can wait before executing another transaction part (ms).n"
  892.     "This is the time the transaction coordinator waits for the applicationn"
  893.     "to execute or send another part (query, statement) of the transaction.n"
  894.     "If the application takes too long time, the transaction gets aborted.n"
  895.     "Timeout set to 0 means that we don't timeout at all on application wait.",
  896.     ConfigInfo::CI_USED,
  897.     true,
  898.     ConfigInfo::CI_INT,
  899.     STR_VALUE(MAX_INT_RNIL),
  900.     "0",
  901.     STR_VALUE(MAX_INT_RNIL) },
  903.   {
  904.     CFG_DB_TRANSACTION_DEADLOCK_TIMEOUT,
  905.     "TransactionDeadlockDetectionTimeout",
  906.     DB_TOKEN,
  907.     "Time transaction can be executing in a DB node (ms).n"
  908.     "This is the time the transaction coordinator waits for each database noden"
  909.     "of the transaction to execute a request. If the database node takes toon"
  910.     "long time, the transaction gets aborted.",
  911.     ConfigInfo::CI_USED,
  912.     true,
  913.     ConfigInfo::CI_INT,
  914.     "1200",
  915.     "50",
  916.     STR_VALUE(MAX_INT_RNIL) },
  918.   {
  919.     CFG_DB_LCP_DISC_PAGES_TUP_SR,
  920.     "NoOfDiskPagesToDiskDuringRestartTUP",
  921.     DB_TOKEN,
  922.     "?",
  923.     ConfigInfo::CI_USED,
  924.     true,
  925.     ConfigInfo::CI_INT,
  926.     "40",
  927.     "1",
  928.     STR_VALUE(MAX_INT_RNIL) },
  930.   {
  931.     CFG_DB_LCP_DISC_PAGES_TUP,
  932.     "NoOfDiskPagesToDiskAfterRestartTUP",
  933.     DB_TOKEN,
  934.     "?",
  935.     ConfigInfo::CI_USED,
  936.     true,
  937.     ConfigInfo::CI_INT,
  938.     "40",
  939.     "1",
  940.     STR_VALUE(MAX_INT_RNIL) },
  942.   {
  943.     CFG_DB_LCP_DISC_PAGES_ACC_SR,
  944.     "NoOfDiskPagesToDiskDuringRestartACC",
  945.     DB_TOKEN,
  946.     "?",
  947.     ConfigInfo::CI_USED,
  948.     true,
  949.     ConfigInfo::CI_INT,
  950.     "20",
  951.     "1",
  952.     STR_VALUE(MAX_INT_RNIL) },
  954.   {
  955.     CFG_DB_LCP_DISC_PAGES_ACC,
  956.     "NoOfDiskPagesToDiskAfterRestartACC",
  957.     DB_TOKEN,
  958.     "?",
  959.     ConfigInfo::CI_USED,
  960.     true,
  961.     ConfigInfo::CI_INT,
  962.     "20",
  963.     "1",
  964.     STR_VALUE(MAX_INT_RNIL) },
  965.   
  967.   {
  968.     CFG_DB_DISCLESS,
  969.     "Diskless",
  970.     DB_TOKEN,
  971.     "Run wo/ disk",
  972.     ConfigInfo::CI_USED,
  973.     true,
  974.     ConfigInfo::CI_BOOL,
  975.     "false",
  976.     "false",
  977.     "true"},
  979.   {
  980.     KEY_INTERNAL,
  981.     "Discless",
  982.     DB_TOKEN,
  983.     "Diskless",
  984.     ConfigInfo::CI_DEPRICATED,
  985.     true,
  986.     ConfigInfo::CI_BOOL,
  987.     "false",
  988.     "false",
  989.     "true"},
  990.   
  992.   
  993.   {
  994.     CFG_DB_ARBIT_TIMEOUT,
  995.     "ArbitrationTimeout",
  996.     DB_TOKEN,
  997.     "Max time (milliseconds) database partion waits for arbitration signal",
  998.     ConfigInfo::CI_USED,
  999.     false,
  1000.     ConfigInfo::CI_INT,
  1001.     "3000",
  1002.     "10",
  1003.     STR_VALUE(MAX_INT_RNIL) },
  1005.   {
  1006.     CFG_NODE_DATADIR,
  1007.     "DataDir",
  1008.     DB_TOKEN,
  1009.     "Data directory for this node",
  1010.     ConfigInfo::CI_USED,
  1011.     false,
  1012.     ConfigInfo::CI_STRING,
  1013.     MYSQLCLUSTERDIR,
  1014.     0, 0 },
  1016.   {
  1017.     CFG_DB_FILESYSTEM_PATH,
  1018.     "FileSystemPath",
  1019.     DB_TOKEN,
  1020.     "Path to directory where the "DB_TOKEN_PRINT" node stores its data (directory must exist)",
  1021.     ConfigInfo::CI_USED,
  1022.     false,
  1023.     ConfigInfo::CI_STRING,
  1024.     UNDEFINED,
  1025.     0, 0 },
  1027.   {
  1028.     CFG_LOGLEVEL_STARTUP,
  1029.     "LogLevelStartup",
  1030.     DB_TOKEN,
  1031.     "Node startup info printed on stdout",
  1032.     ConfigInfo::CI_USED,
  1033.     false,
  1034.     ConfigInfo::CI_INT,
  1035.     "1",
  1036.     "0",
  1037.     "15" },
  1038.   
  1039.   {
  1040.     CFG_LOGLEVEL_SHUTDOWN,
  1041.     "LogLevelShutdown",
  1042.     DB_TOKEN,
  1043.     "Node shutdown info printed on stdout",
  1044.     ConfigInfo::CI_USED,
  1045.     false,
  1046.     ConfigInfo::CI_INT,
  1047.     "0",
  1048.     "0",
  1049.     "15" },
  1051.   {
  1052.     CFG_LOGLEVEL_STATISTICS,
  1053.     "LogLevelStatistic",
  1054.     DB_TOKEN,
  1055.     "Transaction, operation, transporter info printed on stdout",
  1056.     ConfigInfo::CI_USED,
  1057.     false,
  1058.     ConfigInfo::CI_INT,
  1059.     "0",
  1060.     "0",
  1061.     "15" },
  1063.   {
  1064.     CFG_LOGLEVEL_CHECKPOINT,
  1065.     "LogLevelCheckpoint",
  1066.     DB_TOKEN,
  1067.     "Local and Global checkpoint info printed on stdout",
  1068.     ConfigInfo::CI_USED,
  1069.     false,
  1070.     ConfigInfo::CI_INT,
  1071.     "0",
  1072.     "0",
  1073.     "15" },
  1075.   {
  1076.     CFG_LOGLEVEL_NODERESTART,
  1077.     "LogLevelNodeRestart",
  1078.     DB_TOKEN,
  1079.     "Node restart, node failure info printed on stdout",
  1080.     ConfigInfo::CI_USED,
  1081.     false,
  1082.     ConfigInfo::CI_INT,
  1083.     "0",
  1084.     "0",
  1085.     "15" },
  1087.   {
  1088.     CFG_LOGLEVEL_CONNECTION,
  1089.     "LogLevelConnection",
  1090.     DB_TOKEN,
  1091.     "Node connect/disconnect info printed on stdout",
  1092.     ConfigInfo::CI_USED,
  1093.     false,
  1094.     ConfigInfo::CI_INT,
  1095.     "0",
  1096.     "0",
  1097.     "15" },
  1099.   {
  1100.     CFG_LOGLEVEL_ERROR,
  1101.     "LogLevelError",
  1102.     DB_TOKEN,
  1103.     "Transporter, heartbeat errors printed on stdout",
  1104.     ConfigInfo::CI_USED,
  1105.     false,
  1106.     ConfigInfo::CI_INT,
  1107.     "0",
  1108.     "0",
  1109.     "15" },
  1111.   {
  1112.     CFG_LOGLEVEL_INFO,
  1113.     "LogLevelInfo",
  1114.     DB_TOKEN,
  1115.     "Heartbeat and log info printed on stdout",
  1116.     ConfigInfo::CI_USED,
  1117.     false,
  1118.     ConfigInfo::CI_INT,
  1119.     "0",
  1120.     "0",
  1121.     "15" },
  1123.   /**
  1124.    * Backup
  1125.    */
  1126.   { 
  1127.     CFG_DB_PARALLEL_BACKUPS,
  1128.     "ParallelBackups",
  1129.     DB_TOKEN,
  1130.     "Maximum number of parallel backups",
  1131.     ConfigInfo::CI_NOTIMPLEMENTED,
  1132.     false,
  1133.     ConfigInfo::CI_INT,
  1134.     "1",
  1135.     "1",
  1136.     "1" },
  1137.   
  1138.   { 
  1139.     CFG_DB_BACKUP_DATADIR,
  1140.     "BackupDataDir",
  1141.     DB_TOKEN,
  1142.     "Path to where to store backups",
  1143.     ConfigInfo::CI_USED,
  1144.     false,
  1145.     ConfigInfo::CI_STRING,
  1146.     UNDEFINED,
  1147.     0, 0 },
  1148.   
  1149.   { 
  1150.     CFG_DB_BACKUP_MEM,
  1151.     "BackupMemory",
  1152.     DB_TOKEN,
  1153.     "Total memory allocated for backups per node (in bytes)",
  1154.     ConfigInfo::CI_USED,
  1155.     false,
  1156.     ConfigInfo::CI_INT,
  1157.     "4M", // sum of BackupDataBufferSize and BackupLogBufferSize
  1158.     "0",
  1159.     STR_VALUE(MAX_INT_RNIL) },
  1160.   
  1161.   { 
  1162.     CFG_DB_BACKUP_DATA_BUFFER_MEM,
  1163.     "BackupDataBufferSize",
  1164.     DB_TOKEN,
  1165.     "Default size of databuffer for a backup (in bytes)",
  1166.     ConfigInfo::CI_USED,
  1167.     false,
  1168.     ConfigInfo::CI_INT,
  1169.     "2M", // remember to change BackupMemory
  1170.     "0",
  1171.     STR_VALUE(MAX_INT_RNIL) },
  1173.   { 
  1174.     CFG_DB_BACKUP_LOG_BUFFER_MEM,
  1175.     "BackupLogBufferSize",
  1176.     DB_TOKEN,
  1177.     "Default size of logbuffer for a backup (in bytes)",
  1178.     ConfigInfo::CI_USED,
  1179.     false,
  1180.     ConfigInfo::CI_INT,
  1181.     "2M", // remember to change BackupMemory
  1182.     "0",
  1183.     STR_VALUE(MAX_INT_RNIL) },
  1185.   { 
  1186.     CFG_DB_BACKUP_WRITE_SIZE,
  1187.     "BackupWriteSize",
  1188.     DB_TOKEN,
  1189.     "Default size of filesystem writes made by backup (in bytes)",
  1190.     ConfigInfo::CI_USED,
  1191.     false,
  1192.     ConfigInfo::CI_INT,
  1193.     "32K",
  1194.     "0",
  1195.     STR_VALUE(MAX_INT_RNIL) },
  1197.   /***************************************************************************
  1198.    * API
  1199.    ***************************************************************************/
  1200.   {
  1201.     CFG_SECTION_NODE,
  1202.     API_TOKEN,
  1203.     API_TOKEN,
  1204.     "Node section",
  1205.     ConfigInfo::CI_USED,
  1206.     false,
  1207.     ConfigInfo::CI_SECTION,
  1208.     (const char *)NODE_TYPE_API, 
  1209.     0, 0
  1210.   },
  1212.   {
  1213.     CFG_NODE_HOST,
  1214.     "HostName",
  1215.     API_TOKEN,
  1216.     "Name of computer for this node",
  1217.     ConfigInfo::CI_INTERNAL,
  1218.     false,
  1219.     ConfigInfo::CI_STRING,
  1220.     "",
  1221.     0, 0 },
  1223.   {
  1224.     CFG_NODE_SYSTEM,
  1225.     "System",
  1226.     API_TOKEN,
  1227.     "Name of system for this node",
  1228.     ConfigInfo::CI_INTERNAL,
  1229.     false,
  1230.     ConfigInfo::CI_STRING,
  1231.     UNDEFINED,
  1232.     0, 0 },
  1234.   {
  1235.     CFG_NODE_ID,
  1236.     "Id",
  1237.     API_TOKEN,
  1238.     "Number identifying application node ("API_TOKEN_PRINT")",
  1239.     ConfigInfo::CI_USED,
  1240.     false,
  1241.     ConfigInfo::CI_INT,
  1242.     MANDATORY,
  1243.     "1",
  1244.     STR_VALUE(MAX_NODES) },
  1246.   {
  1247.     KEY_INTERNAL,
  1248.     "ExecuteOnComputer",
  1249.     API_TOKEN,
  1250.     "String referencing an earlier defined COMPUTER",
  1251.     ConfigInfo::CI_USED,
  1252.     false,
  1253.     ConfigInfo::CI_STRING,
  1254.     UNDEFINED,
  1255.     0, 0 },
  1257.   {
  1258.     CFG_NODE_ARBIT_RANK,
  1259.     "ArbitrationRank",
  1260.     API_TOKEN,
  1261.     "If 0, then "API_TOKEN_PRINT" is not arbitrator. Kernel selects arbitrators in order 1, 2",
  1262.     ConfigInfo::CI_USED,
  1263.     false,
  1264.     ConfigInfo::CI_INT,
  1265.     "0",
  1266.     "0",
  1267.     "2" },
  1269.   {
  1270.     CFG_NODE_ARBIT_DELAY,
  1271.     "ArbitrationDelay",
  1272.     API_TOKEN,
  1273.     "When asked to arbitrate, arbitrator waits this long before voting (msec)",
  1274.     ConfigInfo::CI_USED,
  1275.     false,
  1276.     ConfigInfo::CI_INT,
  1277.     "0",
  1278.     "0",
  1279.     STR_VALUE(MAX_INT_RNIL) },
  1281.   {
  1282.     CFG_MAX_SCAN_BATCH_SIZE,
  1283.     "MaxScanBatchSize",
  1284.     "API",
  1285.     "The maximum collective batch size for one scan",
  1286.     ConfigInfo::CI_USED,
  1287.     false,
  1288.     ConfigInfo::CI_INT,
  1289.     STR_VALUE(MAX_SCAN_BATCH_SIZE),
  1290.     "32k",
  1291.     "16M" },
  1292.   
  1293.   {
  1294.     CFG_BATCH_BYTE_SIZE,
  1295.     "BatchByteSize",
  1296.     "API",
  1297.     "The default batch size in bytes",
  1298.     ConfigInfo::CI_USED,
  1299.     false,
  1300.     ConfigInfo::CI_INT,
  1301.     STR_VALUE(SCAN_BATCH_SIZE),
  1302.     "1k",
  1303.     "1M" },
  1305.   {
  1306.     CFG_BATCH_SIZE,
  1307.     "BatchSize",
  1308.     "API",
  1309.     "The default batch size in number of records",
  1310.     ConfigInfo::CI_USED,
  1311.     false,
  1312.     ConfigInfo::CI_INT,
  1313.     STR_VALUE(DEF_BATCH_SIZE),
  1314.     "1",
  1315.     STR_VALUE(MAX_PARALLEL_OP_PER_SCAN) },
  1317.   /****************************************************************************
  1318.    * MGM
  1319.    ***************************************************************************/
  1320.   {
  1321.     CFG_SECTION_NODE,
  1322.     MGM_TOKEN,
  1323.     MGM_TOKEN,
  1324.     "Node section",
  1325.     ConfigInfo::CI_USED,
  1326.     false,
  1327.     ConfigInfo::CI_SECTION,
  1328.     (const char *)NODE_TYPE_MGM, 
  1329.     0, 0
  1330.   },
  1332.   {
  1333.     CFG_NODE_HOST,
  1334.     "HostName",
  1335.     MGM_TOKEN,
  1336.     "Name of computer for this node",
  1337.     ConfigInfo::CI_INTERNAL,
  1338.     false,
  1339.     ConfigInfo::CI_STRING,
  1340.     "",
  1341.     0, 0 },
  1343.   {
  1344.     CFG_NODE_DATADIR,
  1345.     "DataDir",
  1346.     MGM_TOKEN,
  1347.     "Data directory for this node",
  1348.     ConfigInfo::CI_USED,
  1349.     false,
  1350.     ConfigInfo::CI_STRING,
  1351.     MYSQLCLUSTERDIR,
  1352.     0, 0 },
  1354.   {
  1355.     CFG_NODE_SYSTEM,
  1356.     "System",
  1357.     MGM_TOKEN,
  1358.     "Name of system for this node",
  1359.     ConfigInfo::CI_INTERNAL,
  1360.     false,
  1361.     ConfigInfo::CI_STRING,
  1362.     UNDEFINED,
  1363.     0, 0 },
  1365.   {
  1366.     CFG_NODE_ID,
  1367.     "Id",
  1368.     MGM_TOKEN,
  1369.     "Number identifying the management server node ("MGM_TOKEN_PRINT")",
  1370.     ConfigInfo::CI_USED,
  1371.     false,
  1372.     ConfigInfo::CI_INT,
  1373.     MANDATORY,
  1374.     "1",
  1375.     STR_VALUE(MAX_NODES) },
  1376.   
  1377.   {
  1378.     CFG_LOG_DESTINATION,
  1379.     "LogDestination",
  1380.     MGM_TOKEN,
  1381.     "String describing where logmessages are sent",
  1382.     ConfigInfo::CI_USED,
  1383.     false,
  1384.     ConfigInfo::CI_STRING,
  1385.     0,
  1386.     0, 0 },
  1387.   
  1388.   {
  1389.     KEY_INTERNAL,
  1390.     "ExecuteOnComputer",
  1391.     MGM_TOKEN,
  1392.     "String referencing an earlier defined COMPUTER",
  1393.     ConfigInfo::CI_USED,
  1394.     false,
  1395.     ConfigInfo::CI_STRING,
  1396.     0,
  1397.     0, 0 },
  1399.   {
  1400.     KEY_INTERNAL,
  1401.     "MaxNoOfSavedEvents",
  1402.     MGM_TOKEN,
  1403.     "",
  1404.     ConfigInfo::CI_USED,
  1405.     false,
  1406.     ConfigInfo::CI_INT,
  1407.     "100",
  1408.     "0",
  1409.     STR_VALUE(MAX_INT_RNIL) },
  1411.   {
  1412.     CFG_MGM_PORT,
  1413.     "PortNumber",
  1414.     MGM_TOKEN,
  1415.     "Port number to give commands to/fetch configurations from management server",
  1416.     ConfigInfo::CI_USED,
  1417.     false,
  1418.     ConfigInfo::CI_INT,
  1419.     NDB_PORT,
  1420.     "0",
  1421.     STR_VALUE(MAX_INT_RNIL) },
  1423.   {
  1424.     KEY_INTERNAL,
  1425.     "PortNumberStats",
  1426.     MGM_TOKEN,
  1427.     "Port number used to get statistical information from a management server",
  1428.     ConfigInfo::CI_USED,
  1429.     false,
  1430.     ConfigInfo::CI_INT,
  1431.     UNDEFINED,
  1432.     "0",
  1433.     STR_VALUE(MAX_INT_RNIL) },
  1435.   {
  1436.     CFG_NODE_ARBIT_RANK,
  1437.     "ArbitrationRank",
  1438.     MGM_TOKEN,
  1439.     "If 0, then "MGM_TOKEN_PRINT" is not arbitrator. Kernel selects arbitrators in order 1, 2",
  1440.     ConfigInfo::CI_USED,
  1441.     false,
  1442.     ConfigInfo::CI_INT,
  1443.     "1",
  1444.     "0",
  1445.     "2" },
  1447.   {
  1448.     CFG_NODE_ARBIT_DELAY,
  1449.     "ArbitrationDelay",
  1450.     MGM_TOKEN,
  1451.     "",
  1452.     ConfigInfo::CI_USED,
  1453.     false,
  1454.     ConfigInfo::CI_INT,
  1455.     "0",
  1456.     "0",
  1457.     STR_VALUE(MAX_INT_RNIL) },
  1459.   /****************************************************************************
  1460.    * TCP
  1461.    ***************************************************************************/
  1462.   {
  1463.     CFG_SECTION_CONNECTION,
  1464.     "TCP",
  1465.     "TCP",
  1466.     "Connection section",
  1467.     ConfigInfo::CI_USED,
  1468.     false,
  1469.     ConfigInfo::CI_SECTION,
  1470.     (const char *)CONNECTION_TYPE_TCP, 
  1471.     0, 0
  1472.   },
  1474.   {
  1475.     CFG_CONNECTION_HOSTNAME_1,
  1476.     "HostName1",
  1477.     "TCP",
  1478.     "Name/IP of computer on one side of the connection",
  1479.     ConfigInfo::CI_INTERNAL,
  1480.     false,
  1481.     ConfigInfo::CI_STRING,
  1482.     UNDEFINED,
  1483.     0, 0 },
  1485.   {
  1486.     CFG_CONNECTION_HOSTNAME_2,
  1487.     "HostName2",
  1488.     "TCP",
  1489.     "Name/IP of computer on one side of the connection",
  1490.     ConfigInfo::CI_INTERNAL,
  1491.     false,
  1492.     ConfigInfo::CI_STRING,
  1493.     UNDEFINED,
  1494.     0, 0 },
  1496.   {
  1497.     CFG_CONNECTION_NODE_1,
  1498.     "NodeId1",
  1499.     "TCP",
  1500.     "Id of node ("DB_TOKEN_PRINT", "API_TOKEN_PRINT" or "MGM_TOKEN_PRINT") on one side of the connection",
  1501.     ConfigInfo::CI_USED,
  1502.     false,
  1503.     ConfigInfo::CI_STRING,
  1504.     MANDATORY,
  1505.     0, 0 },
  1507.   {
  1508.     CFG_CONNECTION_NODE_2,
  1509.     "NodeId2",
  1510.     "TCP",
  1511.     "Id of node ("DB_TOKEN_PRINT", "API_TOKEN_PRINT" or "MGM_TOKEN_PRINT") on one side of the connection",
  1512.     ConfigInfo::CI_USED,
  1513.     false,
  1514.     ConfigInfo::CI_STRING,
  1515.     MANDATORY,
  1516.     0, 0 },
  1518.   {
  1519.     CFG_CONNECTION_GROUP,
  1520.     "Group",
  1521.     "TCP",
  1522.     "",
  1523.     ConfigInfo::CI_USED,
  1524.     false,
  1525.     ConfigInfo::CI_INT,
  1526.     "55",
  1527.     "0", "200" },
  1529.   {
  1530.     CFG_CONNECTION_SEND_SIGNAL_ID,
  1531.     "SendSignalId",
  1532.     "TCP",
  1533.     "Sends id in each signal.  Used in trace files.",
  1534.     ConfigInfo::CI_USED,
  1535.     false,
  1536.     ConfigInfo::CI_BOOL,
  1537.     "true",
  1538.     "false",
  1539.     "true" },
  1542.   {
  1543.     CFG_CONNECTION_CHECKSUM,
  1544.     "Checksum",
  1545.     "TCP",
  1546.     "If checksum is enabled, all signals between nodes are checked for errors",
  1547.     ConfigInfo::CI_USED,
  1548.     false,
  1549.     ConfigInfo::CI_BOOL,
  1550.     "false",
  1551.     "false",
  1552.     "true" },
  1554.   {
  1555.     CFG_CONNECTION_SERVER_PORT,
  1556.     "PortNumber",
  1557.     "TCP",
  1558.     "Port used for this transporter",
  1559.     ConfigInfo::CI_USED,
  1560.     false,
  1561.     ConfigInfo::CI_INT,
  1562.     MANDATORY,
  1563.     "0",
  1564.     STR_VALUE(MAX_INT_RNIL) },
  1566.   {
  1567.     CFG_TCP_SEND_BUFFER_SIZE,
  1568.     "SendBufferMemory",
  1569.     "TCP",
  1570.     "Bytes of buffer for signals sent from this node",
  1571.     ConfigInfo::CI_USED,
  1572.     false,
  1573.     ConfigInfo::CI_INT,
  1574.     "256K",
  1575.     "64K",
  1576.     STR_VALUE(MAX_INT_RNIL) },
  1578.   {
  1579.     CFG_TCP_RECEIVE_BUFFER_SIZE,
  1580.     "ReceiveBufferMemory",
  1581.     "TCP",
  1582.     "Bytes of buffer for signals received by this node",
  1583.     ConfigInfo::CI_USED,
  1584.     false,
  1585.     ConfigInfo::CI_INT,
  1586.     "64K",
  1587.     "16K",
  1588.     STR_VALUE(MAX_INT_RNIL) },
  1590.   {
  1591.     CFG_TCP_PROXY,
  1592.     "Proxy",
  1593.     "TCP",
  1594.     "",
  1595.     ConfigInfo::CI_USED,
  1596.     false,
  1597.     ConfigInfo::CI_STRING,
  1598.     UNDEFINED,
  1599.     0, 0 },
  1601.   {
  1602.     CFG_CONNECTION_NODE_1_SYSTEM,
  1603.     "NodeId1_System",
  1604.     "TCP",
  1605.     "System for node 1 in connection",
  1606.     ConfigInfo::CI_INTERNAL,
  1607.     false,
  1608.     ConfigInfo::CI_STRING,
  1609.     UNDEFINED,
  1610.     0, 0 },
  1612.   {
  1613.     CFG_CONNECTION_NODE_2_SYSTEM,
  1614.     "NodeId2_System",
  1615.     "TCP",
  1616.     "System for node 2 in connection",
  1617.     ConfigInfo::CI_INTERNAL,
  1618.     false,
  1619.     ConfigInfo::CI_STRING,
  1620.     UNDEFINED,
  1621.     0, 0 },
  1622.   
  1624.   /****************************************************************************
  1625.    * SHM
  1626.    ***************************************************************************/
  1627.   {
  1628.     CFG_SECTION_CONNECTION,
  1629.     "SHM",
  1630.     "SHM",
  1631.     "Connection section",
  1632.     ConfigInfo::CI_USED,
  1633.     false,
  1634.     ConfigInfo::CI_SECTION,
  1635.     (const char *)CONNECTION_TYPE_SHM, 
  1636.     0, 0 },
  1638.   {
  1639.     CFG_CONNECTION_HOSTNAME_1,
  1640.     "HostName1",
  1641.     "SHM",
  1642.     "Name/IP of computer on one side of the connection",
  1643.     ConfigInfo::CI_INTERNAL,
  1644.     false,
  1645.     ConfigInfo::CI_STRING,
  1646.     UNDEFINED,
  1647.     0, 0 },
  1649.   {
  1650.     CFG_CONNECTION_HOSTNAME_2,
  1651.     "HostName2",
  1652.     "SHM",
  1653.     "Name/IP of computer on one side of the connection",
  1654.     ConfigInfo::CI_INTERNAL,
  1655.     false,
  1656.     ConfigInfo::CI_STRING,
  1657.     UNDEFINED,
  1658.     0, 0 },
  1660.   {
  1661.     CFG_CONNECTION_SERVER_PORT,
  1662.     "PortNumber",
  1663.     "SHM",
  1664.     "Port used for this transporter",
  1665.     ConfigInfo::CI_USED,
  1666.     false,
  1667.     ConfigInfo::CI_INT,
  1668.     MANDATORY,
  1669.     "0", 
  1670.     STR_VALUE(MAX_INT_RNIL) },
  1672.   {
  1673.     CFG_SHM_SIGNUM,
  1674.     "Signum",
  1675.     "SHM",
  1676.     "Signum to be used for signalling",
  1677.     ConfigInfo::CI_USED,
  1678.     false,
  1679.     ConfigInfo::CI_INT,
  1680.     UNDEFINED,
  1681.     "0", 
  1682.     STR_VALUE(MAX_INT_RNIL) },
  1684.   {
  1685.     CFG_CONNECTION_NODE_1,
  1686.     "NodeId1",
  1687.     "SHM",
  1688.     "Id of node ("DB_TOKEN_PRINT", "API_TOKEN_PRINT" or "MGM_TOKEN_PRINT") on one side of the connection",
  1689.     ConfigInfo::CI_USED,
  1690.     false,
  1691.     ConfigInfo::CI_STRING,
  1692.     MANDATORY,
  1693.     0, 0 },
  1694.   
  1695.   {
  1696.     CFG_CONNECTION_NODE_2,
  1697.     "NodeId2",
  1698.     "SHM",
  1699.     "Id of node ("DB_TOKEN_PRINT", "API_TOKEN_PRINT" or "MGM_TOKEN_PRINT") on one side of the connection",
  1700.     ConfigInfo::CI_USED,
  1701.     false,
  1702.     ConfigInfo::CI_STRING,
  1703.     MANDATORY,
  1704.     0, 0 },
  1705.   
  1706.   {
  1707.     CFG_CONNECTION_GROUP,
  1708.     "Group",
  1709.     "SHM",
  1710.     "",
  1711.     ConfigInfo::CI_USED,
  1712.     false,
  1713.     ConfigInfo::CI_INT,
  1714.     "35",
  1715.     "0", "200" },
  1717.   {
  1718.     CFG_CONNECTION_SEND_SIGNAL_ID,
  1719.     "SendSignalId",
  1720.     "SHM",
  1721.     "Sends id in each signal.  Used in trace files.",
  1722.     ConfigInfo::CI_USED,
  1723.     false,
  1724.     ConfigInfo::CI_BOOL,
  1725.     "false",
  1726.     "false",
  1727.     "true" },
  1728.   
  1729.   
  1730.   {
  1731.     CFG_CONNECTION_CHECKSUM,
  1732.     "Checksum",
  1733.     "SHM",
  1734.     "If checksum is enabled, all signals between nodes are checked for errors",
  1735.     ConfigInfo::CI_USED,
  1736.     false,
  1737.     ConfigInfo::CI_BOOL,
  1738.     "true",
  1739.     "false",
  1740.     "true" },
  1741.   
  1742.   {
  1743.     CFG_SHM_KEY,
  1744.     "ShmKey",
  1745.     "SHM",
  1746.     "A shared memory key",
  1747.     ConfigInfo::CI_USED,
  1748.     false,
  1749.     ConfigInfo::CI_INT,
  1750.     "0",
  1751.     "0",
  1752.     STR_VALUE(MAX_INT_RNIL) },
  1753.   
  1754.   {
  1755.     CFG_SHM_BUFFER_MEM,
  1756.     "ShmSize",
  1757.     "SHM",
  1758.     "Size of shared memory segment",
  1759.     ConfigInfo::CI_USED,
  1760.     false,
  1761.     ConfigInfo::CI_INT,
  1762.     "1M",
  1763.     "64K",
  1764.     STR_VALUE(MAX_INT_RNIL) },
  1766.   {
  1767.     CFG_CONNECTION_NODE_1_SYSTEM,
  1768.     "NodeId1_System",
  1769.     "SHM",
  1770.     "System for node 1 in connection",
  1771.     ConfigInfo::CI_INTERNAL,
  1772.     false,
  1773.     ConfigInfo::CI_STRING,
  1774.     UNDEFINED,
  1775.     0, 0 },
  1777.   {
  1778.     CFG_CONNECTION_NODE_2_SYSTEM,
  1779.     "NodeId2_System",
  1780.     "SHM",
  1781.     "System for node 2 in connection",
  1782.     ConfigInfo::CI_INTERNAL,
  1783.     false,
  1784.     ConfigInfo::CI_STRING,
  1785.     UNDEFINED,
  1786.     0, 0 },
  1788.   /****************************************************************************
  1789.    * SCI
  1790.    ***************************************************************************/
  1791.   {
  1792.     CFG_SECTION_CONNECTION,
  1793.     "SCI",
  1794.     "SCI",
  1795.     "Connection section",
  1796.     ConfigInfo::CI_USED,
  1797.     false,
  1798.     ConfigInfo::CI_SECTION,
  1799.     (const char *)CONNECTION_TYPE_SCI, 
  1800.     0, 0 
  1801.   },
  1803.   {
  1804.     CFG_CONNECTION_NODE_1,
  1805.     "NodeId1",
  1806.     "SCI",
  1807.     "Id of node ("DB_TOKEN_PRINT", "API_TOKEN_PRINT" or "MGM_TOKEN_PRINT") on one side of the connection",
  1808.     ConfigInfo::CI_USED,
  1809.     false,
  1810.     ConfigInfo::CI_STRING,
  1811.     MANDATORY,
  1812.     "0",
  1813.     STR_VALUE(MAX_INT_RNIL) },
  1815.   {
  1816.     CFG_CONNECTION_NODE_2,
  1817.     "NodeId2",
  1818.     "SCI",
  1819.     "Id of node ("DB_TOKEN_PRINT", "API_TOKEN_PRINT" or "MGM_TOKEN_PRINT") on one side of the connection",
  1820.     ConfigInfo::CI_USED,
  1821.     false,
  1822.     ConfigInfo::CI_STRING,
  1823.     MANDATORY,
  1824.     "0",
  1825.     STR_VALUE(MAX_INT_RNIL) },
  1827.   {
  1828.     CFG_CONNECTION_GROUP,
  1829.     "Group",
  1830.     "SCI",
  1831.     "",
  1832.     ConfigInfo::CI_USED,
  1833.     false,
  1834.     ConfigInfo::CI_INT,
  1835.     "15",
  1836.     "0", "200" },
  1838.   {
  1839.     CFG_CONNECTION_HOSTNAME_1,
  1840.     "HostName1",
  1841.     "SCI",
  1842.     "Name/IP of computer on one side of the connection",
  1843.     ConfigInfo::CI_INTERNAL,
  1844.     false,
  1845.     ConfigInfo::CI_STRING,
  1846.     UNDEFINED,
  1847.     0, 0 },
  1849.   {
  1850.     CFG_CONNECTION_HOSTNAME_2,
  1851.     "HostName2",
  1852.     "SCI",
  1853.     "Name/IP of computer on one side of the connection",
  1854.     ConfigInfo::CI_INTERNAL,
  1855.     false,
  1856.     ConfigInfo::CI_STRING,
  1857.     UNDEFINED,
  1858.     0, 0 },
  1860.   {
  1861.     CFG_CONNECTION_SERVER_PORT,
  1862.     "PortNumber",
  1863.     "SCI",
  1864.     "Port used for this transporter",
  1865.     ConfigInfo::CI_USED,
  1866.     false,
  1867.     ConfigInfo::CI_INT,
  1868.     MANDATORY,
  1869.     "0", 
  1870.     STR_VALUE(MAX_INT_RNIL) },
  1872.   {
  1873.     CFG_SCI_HOST1_ID_0,
  1874.     "Host1SciId0",
  1875.     "SCI",
  1876.     "SCI-node id for adapter 0 on Host1 (a computer can have two adapters)",
  1877.     ConfigInfo::CI_USED,
  1878.     false,
  1879.     ConfigInfo::CI_INT,
  1880.     MANDATORY,
  1881.     "0",
  1882.     STR_VALUE(MAX_INT_RNIL) },
  1884.   {
  1885.     CFG_SCI_HOST1_ID_1,
  1886.     "Host1SciId1",
  1887.     "SCI",
  1888.     "SCI-node id for adapter 1 on Host1 (a computer can have two adapters)",
  1889.     ConfigInfo::CI_USED,
  1890.     false,
  1891.     ConfigInfo::CI_INT,
  1892.     "0",
  1893.     "0",
  1894.     STR_VALUE(MAX_INT_RNIL) },
  1896.   {
  1897.     CFG_SCI_HOST2_ID_0,
  1898.     "Host2SciId0",
  1899.     "SCI",
  1900.     "SCI-node id for adapter 0 on Host2 (a computer can have two adapters)",
  1901.     ConfigInfo::CI_USED,
  1902.     false,
  1903.     ConfigInfo::CI_INT,
  1904.     MANDATORY,
  1905.     "0",
  1906.     STR_VALUE(MAX_INT_RNIL) },
  1908.   {
  1909.     CFG_SCI_HOST2_ID_1,
  1910.     "Host2SciId1",
  1911.     "SCI",
  1912.     "SCI-node id for adapter 1 on Host2 (a computer can have two adapters)",
  1913.     ConfigInfo::CI_USED,
  1914.     false,
  1915.     ConfigInfo::CI_INT,
  1916.     "0",
  1917.     "0",
  1918.     STR_VALUE(MAX_INT_RNIL) },
  1920.   {
  1921.     CFG_CONNECTION_SEND_SIGNAL_ID,
  1922.     "SendSignalId",
  1923.     "SCI",
  1924.     "Sends id in each signal.  Used in trace files.",
  1925.     ConfigInfo::CI_USED,
  1926.     false,
  1927.     ConfigInfo::CI_BOOL,
  1928.     "true",
  1929.     "false",
  1930.     "true" },
  1932.   {
  1933.     CFG_CONNECTION_CHECKSUM,
  1934.     "Checksum",
  1935.     "SCI",
  1936.     "If checksum is enabled, all signals between nodes are checked for errors",
  1937.     ConfigInfo::CI_USED,
  1938.     false,
  1939.     ConfigInfo::CI_BOOL,
  1940.     "false",
  1941.     "false",
  1942.     "true" },
  1944.   {
  1945.     CFG_SCI_SEND_LIMIT,
  1946.     "SendLimit",
  1947.     "SCI",
  1948.     "Transporter send buffer contents are sent when this no of bytes is buffered",
  1949.     ConfigInfo::CI_USED,
  1950.     false,
  1951.     ConfigInfo::CI_INT,
  1952.     "8K",
  1953.     "128",
  1954.     "32K" },
  1956.   {
  1957.     CFG_SCI_BUFFER_MEM,
  1958.     "SharedBufferSize",
  1959.     "SCI",
  1960.     "Size of shared memory segment",
  1961.     ConfigInfo::CI_USED,
  1962.     false,
  1963.     ConfigInfo::CI_INT,
  1964.     "1M",
  1965.     "64K",
  1966.     STR_VALUE(MAX_INT_RNIL) },
  1968.   {
  1969.     CFG_CONNECTION_NODE_1_SYSTEM,
  1970.     "NodeId1_System",
  1971.     "SCI",
  1972.     "System for node 1 in connection",
  1973.     ConfigInfo::CI_INTERNAL,
  1974.     false,
  1975.     ConfigInfo::CI_STRING,
  1976.     UNDEFINED,
  1977.     0, 0 },
  1979.   {
  1980.     CFG_CONNECTION_NODE_2_SYSTEM,
  1981.     "NodeId2_System",
  1982.     "SCI",
  1983.     "System for node 2 in connection",
  1984.     ConfigInfo::CI_INTERNAL,
  1985.     false,
  1986.     ConfigInfo::CI_STRING,
  1987.     UNDEFINED,
  1988.     0, 0 },
  1990.   /****************************************************************************
  1991.    * OSE
  1992.    ***************************************************************************/
  1993.   {
  1994.     CFG_SECTION_CONNECTION,
  1995.     "OSE",
  1996.     "OSE",
  1997.     "Connection section",
  1998.     ConfigInfo::CI_USED,
  1999.     false,
  2000.     ConfigInfo::CI_SECTION,
  2001.     (const char *)CONNECTION_TYPE_OSE, 
  2002.     0, 0 
  2003.   },
  2005.   {
  2006.     CFG_CONNECTION_HOSTNAME_1,
  2007.     "HostName1",
  2008.     "OSE",
  2009.     "Name of computer on one side of the connection",
  2010.     ConfigInfo::CI_USED,
  2011.     false,
  2012.     ConfigInfo::CI_STRING,
  2013.     UNDEFINED,
  2014.     0, 0 },
  2016.   {
  2017.     CFG_CONNECTION_HOSTNAME_2,
  2018.     "HostName2",
  2019.     "OSE",
  2020.     "Name of computer on one side of the connection",
  2021.     ConfigInfo::CI_USED,
  2022.     false,
  2023.     ConfigInfo::CI_STRING,
  2024.     UNDEFINED,
  2025.     0, 0 },
  2027.   {
  2028.     CFG_CONNECTION_NODE_1,
  2029.     "NodeId1",
  2030.     "OSE",
  2031.     "Id of node ("DB_TOKEN_PRINT", "API_TOKEN_PRINT" or "MGM_TOKEN_PRINT") on one side of the connection",
  2032.     ConfigInfo::CI_USED,
  2033.     false,
  2034.     ConfigInfo::CI_INT,
  2035.     MANDATORY,
  2036.     "0",
  2037.     STR_VALUE(MAX_INT_RNIL) },
  2039.   {
  2040.     CFG_CONNECTION_NODE_2,
  2041.     "NodeId2",
  2042.     "OSE",
  2043.     "Id of node ("DB_TOKEN_PRINT", "API_TOKEN_PRINT" or "MGM_TOKEN_PRINT") on one side of the connection",
  2044.     ConfigInfo::CI_USED,
  2045.     false,
  2046.     ConfigInfo::CI_INT,
  2047.     UNDEFINED,
  2048.     "0",
  2049.     STR_VALUE(MAX_INT_RNIL) },
  2051.   {
  2052.     CFG_CONNECTION_SEND_SIGNAL_ID,
  2053.     "SendSignalId",
  2054.     "OSE",
  2055.     "Sends id in each signal.  Used in trace files.",
  2056.     ConfigInfo::CI_USED,
  2057.     false,
  2058.     ConfigInfo::CI_BOOL,
  2059.     "true",
  2060.     "false",
  2061.     "true" },
  2063.   {
  2064.     CFG_CONNECTION_CHECKSUM,
  2065.     "Checksum",
  2066.     "OSE",
  2067.     "If checksum is enabled, all signals between nodes are checked for errors",
  2068.     ConfigInfo::CI_USED,
  2069.     false,
  2070.     ConfigInfo::CI_BOOL,
  2071.     "false",
  2072.     "false",
  2073.     "true" },
  2075.   {
  2076.     CFG_OSE_PRIO_A_SIZE,
  2077.     "PrioASignalSize",
  2078.     "OSE",
  2079.     "Size of priority A signals (in bytes)",
  2080.     ConfigInfo::CI_USED,
  2081.     false,
  2082.     ConfigInfo::CI_INT,
  2083.     "1000",
  2084.     "0",
  2085.     STR_VALUE(MAX_INT_RNIL) },
  2087.   {
  2088.     CFG_OSE_PRIO_B_SIZE,
  2089.     "PrioBSignalSize",
  2090.     "OSE",
  2091.     "Size of priority B signals (in bytes)",
  2092.     ConfigInfo::CI_USED,
  2093.     false,
  2094.     ConfigInfo::CI_INT,
  2095.     "1000",
  2096.     "0",
  2097.     STR_VALUE(MAX_INT_RNIL) },
  2098.   
  2099.   {
  2100.     CFG_OSE_RECEIVE_ARRAY_SIZE,
  2101.     "ReceiveArraySize",
  2102.     "OSE",
  2103.     "Number of OSE signals checked for correct ordering (in no of OSE signals)",
  2104.     ConfigInfo::CI_USED,
  2105.     false,
  2106.     ConfigInfo::CI_INT,
  2107.     "10",
  2108.     "0",
  2109.     STR_VALUE(MAX_INT_RNIL) },
  2111.   {
  2112.     CFG_CONNECTION_NODE_1_SYSTEM,
  2113.     "NodeId1_System",
  2114.     "OSE",
  2115.     "System for node 1 in connection",
  2116.     ConfigInfo::CI_INTERNAL,
  2117.     false,
  2118.     ConfigInfo::CI_STRING,
  2119.     UNDEFINED,
  2120.     0, 0 },
  2122.   {
  2123.     CFG_CONNECTION_NODE_2_SYSTEM,
  2124.     "NodeId2_System",
  2125.     "OSE",
  2126.     "System for node 2 in connection",
  2127.     ConfigInfo::CI_INTERNAL,
  2128.     false,
  2129.     ConfigInfo::CI_STRING,
  2130.     UNDEFINED,
  2131.     0, 0 },
  2132. };
  2134. const int ConfigInfo::m_NoOfParams = sizeof(m_ParamInfo) / sizeof(ParamInfo);
  2137. /****************************************************************************
  2138.  * Ctor
  2139.  ****************************************************************************/
  2140. static void require(bool v)
  2141. {
  2142.   if(!v)
  2143.   {
  2144.     if (opt_core)
  2145.       abort();
  2146.     else
  2147.       exit(-1);
  2148.   }
  2149. }
  2151. ConfigInfo::ConfigInfo()
  2152.   : m_info(true), m_systemDefaults(true)
  2153. {
  2154.   int i;
  2155.   Properties *section;
  2156.   const Properties *oldpinfo;
  2158.   for (i=0; i<m_NoOfParams; i++) {
  2159.     const ParamInfo & param = m_ParamInfo[i];
  2160.     Uint64 default_uint64;
  2161.     bool   default_bool;
  2162.     
  2163.     // Create new section if it did not exist
  2164.     if (!m_info.getCopy(param._section, &section)) {
  2165.       Properties newsection(true);
  2166.       m_info.put(param._section, &newsection);
  2167.     }
  2168.     
  2169.     // Get copy of section
  2170.     m_info.getCopy(param._section, &section);
  2171.     
  2172.     // Create pinfo (parameter info) entry 
  2173.     Properties pinfo(true); 
  2174.     pinfo.put("Id",          param._paramId);
  2175.     pinfo.put("Fname",       param._fname);
  2176.     pinfo.put("Description", param._description);
  2177.     pinfo.put("Updateable",  param._updateable);
  2178.     pinfo.put("Type",        param._type);
  2179.     pinfo.put("Status",      param._status);
  2181.     if(param._default == MANDATORY){
  2182.       pinfo.put("Mandatory", (Uint32)1);
  2183.     }
  2185.     switch (param._type) {
  2186.       case CI_BOOL:
  2187.       {
  2188. bool tmp_bool;
  2189. require(InitConfigFileParser::convertStringToBool(param._min, tmp_bool));
  2190. pinfo.put64("Min", tmp_bool);
  2191. require(InitConfigFileParser::convertStringToBool(param._max, tmp_bool));
  2192. pinfo.put64("Max", tmp_bool);
  2193. break;
  2194.       }
  2195.       case CI_INT:
  2196.       case CI_INT64:
  2197.       {
  2198. Uint64 tmp_uint64;
  2199. require(InitConfigFileParser::convertStringToUint64(param._min, tmp_uint64));
  2200. pinfo.put64("Min", tmp_uint64);
  2201. require(InitConfigFileParser::convertStringToUint64(param._max, tmp_uint64));
  2202. pinfo.put64("Max", tmp_uint64);
  2203. break;
  2204.       }
  2205.       case CI_SECTION:
  2206. pinfo.put("SectionType", (Uint32)UintPtr(param._default));
  2207. break;
  2208.       case CI_STRING:
  2209. break;
  2210.     }
  2212.     // Check that pinfo is really new
  2213.     if (section->get(param._fname, &oldpinfo)) {
  2214.       ndbout << "Error: Parameter " << param._fname
  2215.      << " defined twice in section " << param._section
  2216.      << "." << endl;
  2217.       require(false);
  2218.     }
  2219.     
  2220.     // Add new pinfo to section
  2221.     section->put(param._fname, &pinfo);
  2223.     // Replace section with modified section
  2224.     m_info.put(param._section, section, true);
  2225.     
  2226.     if(param._type != ConfigInfo::CI_SECTION){
  2227.       Properties * p;
  2228.       if(!m_systemDefaults.getCopy(param._section, &p)){
  2229. p = new Properties(true);
  2230.       }
  2231.       if(param._default != UNDEFINED &&
  2232.  param._default != MANDATORY){
  2233. switch (param._type)
  2234.         {
  2235.   case CI_SECTION:
  2236.     break;
  2237.   case CI_STRING:
  2238.     require(p->put(param._fname, param._default));
  2239.     break;
  2240.   case CI_BOOL:
  2241.     {
  2242.       bool tmp_bool;
  2243.       require(InitConfigFileParser::convertStringToBool(param._default, default_bool));
  2244.       require(p->put(param._fname, default_bool));
  2245.       break;
  2246.     }
  2247.   case CI_INT:
  2248.   case CI_INT64:
  2249.     {
  2250.       Uint64 tmp_uint64;
  2251.       require(InitConfigFileParser::convertStringToUint64(param._default, default_uint64));
  2252.       require(p->put(param._fname, default_uint64));
  2253.       break;
  2254.     }
  2255. }
  2256.       }
  2257.       require(m_systemDefaults.put(param._section, p, true));
  2258.       delete p;
  2259.     }
  2260.   }
  2261.   
  2262.   for (i=0; i<m_NoOfParams; i++) {
  2263.     if(m_ParamInfo[i]._section == NULL){
  2264.       ndbout << "Check that each entry has a section failed." << endl;
  2265.       ndbout << "Parameter "" << m_ParamInfo[i]._fname << endl; 
  2266.       ndbout << "Edit file " << __FILE__ << "." << endl;
  2267.       require(false);
  2268.     }
  2269.     
  2270.     if(m_ParamInfo[i]._type == ConfigInfo::CI_SECTION)
  2271.       continue;
  2273.     const Properties * p = getInfo(m_ParamInfo[i]._section);
  2274.     if (!p || !p->contains(m_ParamInfo[i]._fname)) {
  2275.       ndbout << "Check that each pname has an fname failed." << endl;
  2276.       ndbout << "Parameter "" << m_ParamInfo[i]._fname 
  2277.      << "" does not exist in section "" 
  2278.      << m_ParamInfo[i]._section << ""." << endl;
  2279.       ndbout << "Edit file " << __FILE__ << "." << endl;
  2280.       require(false);
  2281.     }
  2282.   }
  2283. }
  2285. /****************************************************************************
  2286.  * Getters
  2287.  ****************************************************************************/
  2288. inline void warning(const char * src, const char * arg){
  2289.   ndbout << "Illegal call to ConfigInfo::" << src << "() - " << arg << endl;
  2290.   require(false);
  2291. }
  2293. const Properties * 
  2294. ConfigInfo::getInfo(const char * section) const {
  2295.   const Properties * p;
  2296.   if(!m_info.get(section, &p)){
  2297.     return 0;
  2298.     //    warning("getInfo", section);
  2299.   }
  2300.   return p;
  2301. }
  2303. const Properties * 
  2304. ConfigInfo::getDefaults(const char * section) const {
  2305.   const Properties * p;
  2306.   if(!m_systemDefaults.get(section, &p)){
  2307.     return 0;
  2308.     //warning("getDefaults", section);
  2309.   }
  2310.   return p;
  2311. }
  2313. static
  2314. Uint64
  2315. getInfoInt(const Properties * section, 
  2316.    const char* fname, const char * type){
  2317.   Uint32 val32;
  2318.   const Properties * p;
  2319.   if (section->get(fname, &p) && p->get(type, &val32)) {
  2320.     return val32;
  2321.   }
  2323.   Uint64 val64;
  2324.   if(p && p->get(type, &val64)){
  2325.     return val64;
  2326.   }
  2327.   
  2328.   section->print();
  2329.   if(section->get(fname, &p)){
  2330.     p->print();
  2331.   }
  2333.   warning(type, fname);
  2334.   return 0;
  2335. }
  2337. static
  2338. const char *
  2339. getInfoString(const Properties * section, 
  2340.       const char* fname, const char * type){
  2341.   const char* val;
  2342.   const Properties * p;
  2343.   if (section->get(fname, &p) && p->get(type, &val)) {
  2344.     return val;
  2345.   }
  2346.   warning(type, fname);
  2347.   return val;
  2348. }
  2350. Uint64
  2351. ConfigInfo::getMax(const Properties * section, const char* fname) const {
  2352.   return getInfoInt(section, fname, "Max");
  2353. }
  2355. Uint64
  2356. ConfigInfo::getMin(const Properties * section, const char* fname) const {
  2357.   return getInfoInt(section, fname, "Min");
  2358. }
  2360. Uint64
  2361. ConfigInfo::getDefault(const Properties * section, const char* fname) const {
  2362.   return getInfoInt(section, fname, "Default");
  2363. }
  2365. const char*
  2366. ConfigInfo::getDescription(const Properties * section, 
  2367.    const char* fname) const {
  2368.   return getInfoString(section, fname, "Description");
  2369. }
  2371. bool
  2372. ConfigInfo::isSection(const char * section) const {
  2373.   for (int i = 0; i<m_noOfSectionNames; i++) {
  2374.     if(!strcasecmp(section, m_sectionNames[i])) return true;
  2375.   }
  2376.   return false;
  2377. }
  2379. const char*
  2380. ConfigInfo::nameToAlias(const char * name) {
  2381.   for (int i = 0; m_sectionNameAliases[i].name != 0; i++)
  2382.     if(!strcasecmp(name, m_sectionNameAliases[i].name))
  2383.       return m_sectionNameAliases[i].alias;
  2384.   return 0;
  2385. }
  2387. const char*
  2388. ConfigInfo::getAlias(const char * section) {
  2389.   for (int i = 0; m_sectionNameAliases[i].name != 0; i++)
  2390.     if(!strcasecmp(section, m_sectionNameAliases[i].alias))
  2391.       return m_sectionNameAliases[i].name;
  2392.   return 0;
  2393. }
  2395. bool
  2396. ConfigInfo::verify(const Properties * section, const char* fname, 
  2397.    Uint64 value) const {
  2398.   Uint64 min, max;
  2400.   min = getInfoInt(section, fname, "Min");
  2401.   max = getInfoInt(section, fname, "Max");
  2402.   if(min > max){
  2403.     warning("verify", fname);
  2404.   }
  2405.   if (value >= min && value <= max)
  2406.     return true;
  2407.   else 
  2408.     return false;
  2409. }
  2411. ConfigInfo::Type 
  2412. ConfigInfo::getType(const Properties * section, const char* fname) const {
  2413.   return (ConfigInfo::Type) getInfoInt(section, fname, "Type");
  2414. }
  2416. ConfigInfo::Status
  2417. ConfigInfo::getStatus(const Properties * section, const char* fname) const {
  2418.   return (ConfigInfo::Status) getInfoInt(section, fname, "Status");
  2419. }
  2421. /****************************************************************************
  2422.  * Printers
  2423.  ****************************************************************************/
  2425. void ConfigInfo::print() const {
  2426.   Properties::Iterator it(&m_info);
  2427.   for (const char* n = it.first(); n != NULL; n = it.next()) {
  2428.     print(n);
  2429.   }
  2430. }
  2432. void ConfigInfo::print(const char* section) const {
  2433.   ndbout << "****** " << section << " ******" << endl << endl;
  2434.   const Properties * sec = getInfo(section);
  2435.   Properties::Iterator it(sec);
  2436.   for (const char* n = it.first(); n != NULL; n = it.next()) {
  2437.     // Skip entries with different F- and P-names
  2438.     if (getStatus(sec, n) == ConfigInfo::CI_INTERNAL) continue;
  2439.     if (getStatus(sec, n) == ConfigInfo::CI_DEPRICATED) continue;
  2440.     if (getStatus(sec, n) == ConfigInfo::CI_NOTIMPLEMENTED) continue;
  2441.     print(sec, n);
  2442.   }
  2443. }
  2445. void ConfigInfo::print(const Properties * section, 
  2446.        const char* parameter) const {
  2447.   ndbout << parameter;
  2448.   //  ndbout << getDescription(section, parameter) << endl;
  2449.   switch (getType(section, parameter)) {
  2450.   case ConfigInfo::CI_BOOL:
  2451.     ndbout << " (Boolean value)" << endl;
  2452.     ndbout << getDescription(section, parameter) << endl;
  2453.     if (getDefault(section, parameter) == false) {
  2454.       ndbout << "Default: N (Legal values: Y, N)" << endl; 
  2455.     } else if (getDefault(section, parameter) == true) {
  2456.       ndbout << "Default: Y (Legal values: Y, N)" << endl;
  2457.     } else if (getDefault(section, parameter) == (UintPtr)MANDATORY) {
  2458.       ndbout << "MANDATORY (Legal values: Y, N)" << endl;
  2459.     } else {
  2460.       ndbout << "UNKNOWN" << endl;
  2461.     }
  2462.     ndbout << endl;
  2463.     break;    
  2464.     
  2465.   case ConfigInfo::CI_INT:
  2466.   case ConfigInfo::CI_INT64:
  2467.     ndbout << " (Non-negative Integer)" << endl;
  2468.     ndbout << getDescription(section, parameter) << endl;
  2469.     if (getDefault(section, parameter) == (UintPtr)MANDATORY) {
  2470.       ndbout << "MANDATORY (";
  2471.     } else if (getDefault(section, parameter) == (UintPtr)UNDEFINED) {
  2472.       ndbout << "UNDEFINED (";
  2473.     } else {
  2474.       ndbout << "Default: " << getDefault(section, parameter) << " (";
  2475.     }
  2476.     ndbout << "Min: " << getMin(section, parameter) << ", ";
  2477.     ndbout << "Max: " << getMax(section, parameter) << ")" << endl;
  2478.     ndbout << endl;
  2479.     break;
  2480.     
  2481.   case ConfigInfo::CI_STRING:
  2482.     ndbout << " (String)" << endl;
  2483.     ndbout << getDescription(section, parameter) << endl;
  2484.     if (getDefault(section, parameter) == (UintPtr)MANDATORY) {
  2485.       ndbout << "MANDATORY" << endl;
  2486.     } else {
  2487.       ndbout << "No default value" << endl;
  2488.     }
  2489.     ndbout << endl;
  2490.     break;
  2491.   case ConfigInfo::CI_SECTION:
  2492.     break;
  2493.   }
  2494. }
  2496. /****************************************************************************
  2497.  * Section Rules
  2498.  ****************************************************************************/
  2500. /**
  2501.  * Node rule: Add "Type" and update "NoOfNodes"
  2502.  */
  2503. bool
  2504. transformNode(InitConfigFileParser::Context & ctx, const char * data){
  2506.   Uint32 id;
  2507.   if(!ctx.m_currentSection->get("Id", &id)){
  2508.     Uint32 nextNodeId= 1;
  2509.     ctx.m_userProperties.get("NextNodeId", &nextNodeId);
  2510.     id= nextNodeId;
  2511.     while (ctx.m_userProperties.get("AllocatedNodeId_", id, &id))
  2512.       id++;
  2513.     ctx.m_userProperties.put("NextNodeId", id+1, true);
  2514.     ctx.m_currentSection->put("Id", id);
  2515. #if 0
  2516.     ctx.reportError("Mandatory parameter Id missing from section "
  2517.     "[%s] starting at line: %d",
  2518.     ctx.fname, ctx.m_sectionLineno);
  2519.     return false;
  2520. #endif
  2521.   } else if(ctx.m_userProperties.get("AllocatedNodeId_", id, &id)) {
  2522.     ctx.reportError("Duplicate Id in section "
  2523.     "[%s] starting at line: %d",
  2524.     ctx.fname, ctx.m_sectionLineno);
  2525.     return false;
  2526.   }
  2528.   ctx.m_userProperties.put("AllocatedNodeId_", id, id);
  2529.   BaseString::snprintf(ctx.pname, sizeof(ctx.pname), "Node_%d", id);
  2530.   
  2531.   ctx.m_currentSection->put("Type", ctx.fname);
  2533.   Uint32 nodes = 0;
  2534.   ctx.m_userProperties.get("NoOfNodes", &nodes);
  2535.   ctx.m_userProperties.put("NoOfNodes", ++nodes, true);
  2537.   /**
  2538.    * Update count (per type)
  2539.    */
  2540.   nodes = 0;
  2541.   ctx.m_userProperties.get(ctx.fname, &nodes);
  2542.   ctx.m_userProperties.put(ctx.fname, ++nodes, true);
  2544.   return true;
  2545. }
  2547. static bool checkLocalhostHostnameMix(InitConfigFileParser::Context & ctx, const char * data)
  2548. {
  2549.   DBUG_ENTER("checkLocalhostHostnameMix");
  2550.   const char * hostname= 0;
  2551.   ctx.m_currentSection->get("HostName", &hostname);
  2552.   if (hostname == 0 || hostname[0] == 0)
  2553.     DBUG_RETURN(true);
  2555.   Uint32 localhost_used= 0;
  2556.   if(!strcmp(hostname, "localhost") || !strcmp(hostname, "127.0.0.1")){
  2557.     localhost_used= 1;
  2558.     ctx.m_userProperties.put("$computer-localhost-used", localhost_used);
  2559.     if(!ctx.m_userProperties.get("$computer-localhost", &hostname))
  2560.       DBUG_RETURN(true);
  2561.   } else {
  2562.     ctx.m_userProperties.get("$computer-localhost-used", &localhost_used);
  2563.     ctx.m_userProperties.put("$computer-localhost", hostname);
  2564.   }
  2566.   if (localhost_used) {
  2567.     ctx.reportError("Mixing of localhost (default for [NDBD]HostName) with other hostname(%s) is illegal",
  2568.     hostname);
  2569.     DBUG_RETURN(false);
  2570.   }
  2572.   DBUG_RETURN(true);
  2573. }
  2575. bool
  2576. fixNodeHostname(InitConfigFileParser::Context & ctx, const char * data)
  2577. {
  2578.   const char * hostname;
  2579.   DBUG_ENTER("fixNodeHostname");
  2581.   if (ctx.m_currentSection->get("HostName", &hostname))
  2582.     DBUG_RETURN(checkLocalhostHostnameMix(ctx,0));
  2584.   const char * compId;
  2585.   if(!ctx.m_currentSection->get("ExecuteOnComputer", &compId))
  2586.     DBUG_RETURN(true);
  2587.   
  2588.   const Properties * computer;
  2589.   char tmp[255];
  2590.   BaseString::snprintf(tmp, sizeof(tmp), "Computer_%s", compId);
  2591.   if(!ctx.m_config->get(tmp, &computer)){
  2592.     ctx.reportError("Computer "%s" not declared"
  2593.     "- [%s] starting at line: %d",
  2594.     compId, ctx.fname, ctx.m_sectionLineno);
  2595.     DBUG_RETURN(false);
  2596.   }
  2597.   
  2598.   if(!computer->get("HostName", &hostname)){
  2599.     ctx.reportError("HostName missing in [COMPUTER] (Id: %d) "
  2600.     " - [%s] starting at line: %d",
  2601.     compId, ctx.fname, ctx.m_sectionLineno);
  2602.     DBUG_RETURN(false);
  2603.   }
  2604.   
  2605.   require(ctx.m_currentSection->put("HostName", hostname));
  2606.   DBUG_RETURN(checkLocalhostHostnameMix(ctx,0));
  2607. }
  2609. bool
  2610. fixFileSystemPath(InitConfigFileParser::Context & ctx, const char * data){
  2611.   DBUG_ENTER("fixFileSystemPath");
  2613.   const char * path;
  2614.   if (ctx.m_currentSection->get("FileSystemPath", &path))
  2615.     DBUG_RETURN(true);
  2617.   if (ctx.m_currentSection->get("DataDir", &path)) {
  2618.     require(ctx.m_currentSection->put("FileSystemPath", path));
  2619.     DBUG_RETURN(true);
  2620.   }
  2622.   require(false);
  2623.   DBUG_RETURN(false);
  2624. }
  2626. bool
  2627. fixBackupDataDir(InitConfigFileParser::Context & ctx, const char * data){
  2628.   
  2629.   const char * path;
  2630.   if (ctx.m_currentSection->get("BackupDataDir", &path))
  2631.     return true;
  2633.   if (ctx.m_currentSection->get("FileSystemPath", &path)) {
  2634.     require(ctx.m_currentSection->put("BackupDataDir", path));
  2635.     return true;
  2636.   }
  2638.   require(false);
  2639.   return false;
  2640. }
  2642. bool
  2643. transformExtNode(InitConfigFileParser::Context & ctx, const char * data){
  2645.   Uint32 id;
  2646.   const char * systemName;
  2648.   if(!ctx.m_currentSection->get("Id", &id)){
  2649.     ctx.reportError("Mandatory parameter 'Id' missing from section "
  2650.     "[%s] starting at line: %d",
  2651.     ctx.fname, ctx.m_sectionLineno);
  2652.     return false;
  2653.   }
  2655.   if(!ctx.m_currentSection->get("System", &systemName)){
  2656.     ctx.reportError("Mandatory parameter 'System' missing from section "
  2657.     "[%s] starting at line: %d",
  2658.     ctx.fname, ctx.m_sectionLineno);
  2659.     return false;
  2660.   }
  2662.   ctx.m_currentSection->put("Type", ctx.fname);
  2664.   Uint32 nodes = 0;
  2665.   ctx.m_userProperties.get("ExtNoOfNodes", &nodes);
  2666.   require(ctx.m_userProperties.put("ExtNoOfNodes",++nodes, true));
  2668.   BaseString::snprintf(ctx.pname, sizeof(ctx.pname), "EXTERNAL SYSTEM_%s:Node_%d", 
  2669.    systemName, id);
  2671.   return true;
  2672. }
  2674. /**
  2675.  * Connection rule: Check support of connection
  2676.  */
  2677. bool
  2678. checkConnectionSupport(InitConfigFileParser::Context & ctx, const char * data)
  2679. {
  2680.   int error= 0;
  2681.   if (strcasecmp("TCP",ctx.fname) == 0)
  2682.   {
  2683.     // always enabled
  2684.   }
  2685.   else if (strcasecmp("SHM",ctx.fname) == 0)
  2686.   {
  2687. #ifndef NDB_SHM_TRANSPORTER
  2688.     error= 1;
  2689. #endif
  2690.   }
  2691.   else if (strcasecmp("SCI",ctx.fname) == 0)
  2692.   {
  2693. #ifndef NDB_SCI_TRANSPORTER
  2694.     error= 1;
  2695. #endif
  2696.   }
  2697.   else if (strcasecmp("OSE",ctx.fname) == 0)
  2698.   {
  2699. #ifndef NDB_OSE_TRANSPORTER
  2700.     error= 1;
  2701. #endif
  2702.   }
  2703.   if (error)
  2704.   {
  2705.     ctx.reportError("Binary not compiled with this connection support, "
  2706.     "[%s] starting at line: %d",
  2707.     ctx.fname, ctx.m_sectionLineno);
  2708.     return false;
  2709.   }
  2710.   return true;
  2711. }
  2713. /**
  2714.  * Connection rule: Update "NoOfConnections"
  2715.  */
  2716. bool
  2717. transformConnection(InitConfigFileParser::Context & ctx, const char * data)
  2718. {
  2719.   Uint32 connections = 0;
  2720.   ctx.m_userProperties.get("NoOfConnections", &connections);
  2721.   BaseString::snprintf(ctx.pname, sizeof(ctx.pname), "Connection_%d", connections);
  2722.   ctx.m_userProperties.put("NoOfConnections", ++connections, true);
  2723.   
  2724.   ctx.m_currentSection->put("Type", ctx.fname);
  2725.   return true;
  2726. }
  2728. /**
  2729.  * System rule: Just add it
  2730.  */
  2731. bool
  2732. transformSystem(InitConfigFileParser::Context & ctx, const char * data){
  2734.   const char * name;
  2735.   if(!ctx.m_currentSection->get("Name", &name)){
  2736.     ctx.reportError("Mandatory parameter Name missing from section "
  2737.     "[%s] starting at line: %d",
  2738.     ctx.fname, ctx.m_sectionLineno);
  2739.     return false;
  2740.   }
  2742.   ndbout << "transformSystem " << name << endl;
  2744.   BaseString::snprintf(ctx.pname, sizeof(ctx.pname), "SYSTEM_%s", name);
  2745.   
  2746.   return true;
  2747. }
  2749. /**
  2750.  * External system rule: Just add it
  2751.  */
  2752. bool
  2753. transformExternalSystem(InitConfigFileParser::Context & ctx, const char * data){
  2754.   const char * name;
  2755.   if(!ctx.m_currentSection->get("Name", &name)){
  2756.     ctx.reportError("Mandatory parameter Name missing from section "
  2757.     "[%s] starting at line: %d",
  2758.     ctx.fname, ctx.m_sectionLineno);
  2759.     return false;
  2760.   }
  2761.   BaseString::snprintf(ctx.pname, sizeof(ctx.pname), "EXTERNAL SYSTEM_%s", name);
  2762.   
  2763.   return true;
  2764. }
  2766. /**
  2767.  * Computer rule: Update "NoOfComputers", add "Type"
  2768.  */
  2769. bool
  2770. transformComputer(InitConfigFileParser::Context & ctx, const char * data){
  2771.   const char * id;
  2772.   if(!ctx.m_currentSection->get("Id", &id)){
  2773.     ctx.reportError("Mandatory parameter Id missing from section "
  2774.     "[%s] starting at line: %d",
  2775.     ctx.fname, ctx.m_sectionLineno);
  2776.     return false;
  2777.   }
  2778.   BaseString::snprintf(ctx.pname, sizeof(ctx.pname), "Computer_%s", id);
  2779.   
  2780.   Uint32 computers = 0;
  2781.   ctx.m_userProperties.get("NoOfComputers", &computers);
  2782.   ctx.m_userProperties.put("NoOfComputers", ++computers, true);
  2783.   
  2784.   const char * hostname = 0;
  2785.   ctx.m_currentSection->get("HostName", &hostname);
  2786.   if(!hostname){
  2787.     return true;
  2788.   }
  2789.   
  2790.   return checkLocalhostHostnameMix(ctx,0);
  2791. }
  2793. /**
  2794.  * Apply default values
  2795.  */
  2796. void 
  2797. applyDefaultValues(InitConfigFileParser::Context & ctx,
  2798.    const Properties * defaults)
  2799. {
  2800.   DBUG_ENTER("applyDefaultValues");
  2801.   if(defaults != NULL){
  2802.     Properties::Iterator it(defaults);
  2804.     for(const char * name = it.first(); name != NULL; name = it.next()){
  2805.       ConfigInfo::Status st = ctx.m_info->getStatus(ctx.m_currentInfo, name);
  2806.       if(!ctx.m_currentSection->contains(name)){
  2807. switch (ctx.m_info->getType(ctx.m_currentInfo, name)){
  2808. case ConfigInfo::CI_INT:
  2809. case ConfigInfo::CI_BOOL:{
  2810.   Uint32 val = 0;
  2811.   ::require(defaults->get(name, &val));
  2812.   ctx.m_currentSection->put(name, val);
  2813.           DBUG_PRINT("info",("%s=%d #default",name,val));
  2814.   break;
  2815. }
  2816. case ConfigInfo::CI_INT64:{
  2817.   Uint64 val = 0;
  2818.   ::require(defaults->get(name, &val));
  2819.   ctx.m_currentSection->put64(name, val);
  2820.           DBUG_PRINT("info",("%s=%lld #default",name,val));
  2821.   break;
  2822. }
  2823. case ConfigInfo::CI_STRING:{
  2824.   const char * val;
  2825.   ::require(defaults->get(name, &val));
  2826.   ctx.m_currentSection->put(name, val);
  2827.           DBUG_PRINT("info",("%s=%s #default",name,val));
  2828.   break;
  2829. }
  2830. case ConfigInfo::CI_SECTION:
  2831.   break;
  2832. }
  2833.       }
  2834. #ifndef DBUG_OFF
  2835.       else
  2836.       {
  2837.         switch (ctx.m_info->getType(ctx.m_currentInfo, name)){
  2838.         case ConfigInfo::CI_INT:
  2839.         case ConfigInfo::CI_BOOL:{
  2840.           Uint32 val = 0;
  2841.           ::require(ctx.m_currentSection->get(name, &val));
  2842.           DBUG_PRINT("info",("%s=%d",name,val));
  2843.           break;
  2844.         }
  2845.         case ConfigInfo::CI_INT64:{
  2846.           Uint64 val = 0;
  2847.           ::require(ctx.m_currentSection->get(name, &val));
  2848.           DBUG_PRINT("info",("%s=%lld",name,val));
  2849.           break;
  2850.         }
  2851.         case ConfigInfo::CI_STRING:{
  2852.           const char * val;
  2853.           ::require(ctx.m_currentSection->get(name, &val));
  2854.           DBUG_PRINT("info",("%s=%s",name,val));
  2855.           break;
  2856.         }
  2857.         case ConfigInfo::CI_SECTION:
  2858.           break;
  2859.         }
  2860.       }
  2861. #endif
  2862.     }
  2863.   }
  2864.   DBUG_VOID_RETURN;
  2865. }
  2867. bool
  2868. applyDefaultValues(InitConfigFileParser::Context & ctx, const char * data){
  2869.   
  2870.   if(strcmp(data, "user") == 0)
  2871.     applyDefaultValues(ctx, ctx.m_userDefaults);
  2872.   else if (strcmp(data, "system") == 0)
  2873.     applyDefaultValues(ctx, ctx.m_systemDefaults);
  2874.   else 
  2875.     return false;
  2877.   return true;
  2878. }
  2880. /**
  2881.  * Check that a section contains all MANDATORY parameters
  2882.  */
  2883. bool
  2884. checkMandatory(InitConfigFileParser::Context & ctx, const char * data){
  2886.   Properties::Iterator it(ctx.m_currentInfo);
  2887.   for(const char * name = it.first(); name != NULL; name = it.next()){
  2888.     const Properties * info = NULL;
  2889.     ::require(ctx.m_currentInfo->get(name, &info));
  2890.     Uint32 val;
  2891.     if(info->get("Mandatory", &val)){
  2892.       const char * fname;
  2893.       ::require(info->get("Fname", &fname));
  2894.       if(!ctx.m_currentSection->contains(fname)){
  2895. ctx.reportError("Mandatory parameter %s missing from section "
  2896. "[%s] starting at line: %d",
  2897. fname, ctx.fname, ctx.m_sectionLineno);
  2898. return false;
  2899.       }
  2900.     }
  2901.   }
  2902.   return true;
  2903. }
  2905. /**
  2906.  * Connection rule: Fix node id
  2907.  *
  2908.  * Transform a string "NodeidX" (e.g. "uppsala.32") 
  2909.  * into a Uint32 "NodeIdX" (e.g. 32) and a string "SystemX" (e.g. "uppsala").
  2910.  */
  2911. static bool fixNodeId(InitConfigFileParser::Context & ctx, const char * data)
  2912. {
  2913.   char buf[] = "NodeIdX";  buf[6] = data[sizeof("NodeI")];
  2914.   char sysbuf[] = "SystemX";  sysbuf[6] = data[sizeof("NodeI")];
  2915.   const char* nodeId;
  2916.   require(ctx.m_currentSection->get(buf, &nodeId));
  2918.   char tmpLine[MAX_LINE_LENGTH];
  2919.   strncpy(tmpLine, nodeId, MAX_LINE_LENGTH);
  2920.   char* token1 = strtok(tmpLine, ".");
  2921.   char* token2 = strtok(NULL, ".");
  2922.   Uint32 id;
  2924.   if (token2 == NULL) {                // Only a number given
  2925.     errno = 0;
  2926.     char* p;
  2927.     id = strtol(token1, &p, 10);
  2928.     if (errno != 0) warning("STRTOK1", nodeId);
  2929.     require(ctx.m_currentSection->put(buf, id, true));
  2930.   } else {                             // A pair given (e.g. "uppsala.32")
  2931.     errno = 0;
  2932.     char* p;
  2933.     id = strtol(token2, &p, 10);
  2934.     if (errno != 0) warning("STRTOK2", nodeId);
  2935.     require(ctx.m_currentSection->put(buf, id, true));
  2936.     require(ctx.m_currentSection->put(sysbuf, token1));
  2937.   }
  2938.   return true;
  2939. }
  2941. /**
  2942.  * @returns true if connection is external (one node is external)
  2943.  * Also returns: 
  2944.  * - name of external system in parameter extSystemName, and 
  2945.  * - nodeId of external node in parameter extSystemNodeId.
  2946.  */
  2947. static bool 
  2948. isExtConnection(InitConfigFileParser::Context & ctx, 
  2949. const char **extSystemName, Uint32 * extSystemNodeId){
  2951.   Uint32 nodeId1, nodeId2;
  2953.   if (ctx.m_currentSection->contains("System1") &&
  2954.       ctx.m_currentSection->get("System1", extSystemName) &&
  2955.       ctx.m_currentSection->get("NodeId1", &nodeId1)) {
  2956.     *extSystemNodeId = nodeId1;
  2957.     return true;
  2958.   }
  2960.   if (ctx.m_currentSection->contains("System2") &&
  2961.       ctx.m_currentSection->get("System2", extSystemName) &&
  2962.       ctx.m_currentSection->get("NodeId2", &nodeId2)) {
  2963.     *extSystemNodeId = nodeId2;
  2964.     return true;
  2965.   }
  2967.   return false;
  2968. }
  2970. /**
  2971.  * External Connection Rule: 
  2972.  * If connection is to an external system, then move connection into
  2973.  * external system configuration (i.e. a sub-property).
  2974.  */
  2975. static bool
  2976. fixExtConnection(InitConfigFileParser::Context & ctx, const char * data){
  2978.   const char * extSystemName;
  2979.   Uint32 extSystemNodeId;
  2981.   if (isExtConnection(ctx, &extSystemName, &extSystemNodeId)) {
  2983.     Uint32 connections = 0;
  2984.     ctx.m_userProperties.get("ExtNoOfConnections", &connections);
  2985.     require(ctx.m_userProperties.put("ExtNoOfConnections",++connections, true));
  2987.     char tmpLine1[MAX_LINE_LENGTH];
  2988.     BaseString::snprintf(tmpLine1, MAX_LINE_LENGTH, "Connection_%d", connections-1);
  2990.     /**
  2991.      *  Section:   EXTERNAL SYSTEM_<Ext System Name>
  2992.      */
  2993.     char extSystemPropName[MAX_LINE_LENGTH];
  2994.     strncpy(extSystemPropName, "EXTERNAL SYSTEM_", MAX_LINE_LENGTH);
  2995.     strncat(extSystemPropName, extSystemName, MAX_LINE_LENGTH);
  2996.     strncat(extSystemPropName, ":", MAX_LINE_LENGTH);
  2997.     strncat(extSystemPropName, tmpLine1, MAX_LINE_LENGTH);
  2999.     /**
  3000.      * Increase number of external connections for the system
  3001.      *
  3002.      * @todo Limitation: Only one external system is allowed
  3003.      */
  3004.     require(ctx.m_userProperties.put("ExtSystem", extSystemName, true));
  3005.     
  3006.     /**
  3007.      * Make sure section is stored in right place
  3008.      */
  3009.     strncpy(ctx.pname, extSystemPropName, MAX_LINE_LENGTH);
  3011.     /**
  3012.      * Since this is an external connection, 
  3013.      * decrease number of internal connections
  3014.      */
  3015.     require(ctx.m_userProperties.get("NoOfConnections", &connections));
  3016.     require(ctx.m_userProperties.put("NoOfConnections", --connections, true));
  3017.   }
  3019.   return true;
  3020. }
  3022. /**
  3023.  * Connection rule: Fix hostname
  3024.  * 
  3025.  * Unless Hostname is not already specified, do steps:
  3026.  * -# Via Connection's NodeId lookup Node
  3027.  * -# Via Node's ExecuteOnComputer lookup Hostname
  3028.  * -# Add HostName to Connection
  3029.  */
  3030. static bool
  3031. fixHostname(InitConfigFileParser::Context & ctx, const char * data){
  3032.   
  3033.   char buf[] = "NodeIdX"; buf[6] = data[sizeof("HostNam")];
  3034.   char sysbuf[] = "SystemX"; sysbuf[6] = data[sizeof("HostNam")];
  3035.   
  3036.   if(!ctx.m_currentSection->contains(data)){
  3037.     Uint32 id = 0;
  3038.     require(ctx.m_currentSection->get(buf, &id));
  3039.     
  3040.     const Properties * node;
  3041.     if(!ctx.m_config->get("Node", id, &node))
  3042.     {
  3043.       ctx.reportError("Unknown node: "%d" specified in connection "
  3044.       "[%s] starting at line: %d",
  3045.       id, ctx.fname, ctx.m_sectionLineno);
  3046.       return false;
  3047.     }
  3048.     
  3049.     const char * hostname;
  3050.     require(node->get("HostName", &hostname));
  3051.     require(ctx.m_currentSection->put(data, hostname));
  3052.   }
  3053.   return true;
  3054. }
  3056. /**
  3057.  * Connection rule: Fix port number (using a port number adder)
  3058.  */
  3059. static bool
  3060. fixPortNumber(InitConfigFileParser::Context & ctx, const char * data){
  3062.   DBUG_ENTER("fixPortNumber");
  3064.   Uint32 id1= 0, id2= 0;
  3065.   const char *hostName1;
  3066.   const char *hostName2;
  3067.   require(ctx.m_currentSection->get("NodeId1", &id1));
  3068.   require(ctx.m_currentSection->get("NodeId2", &id2));
  3069.   require(ctx.m_currentSection->get("HostName1", &hostName1));
  3070.   require(ctx.m_currentSection->get("HostName2", &hostName2));
  3071.   DBUG_PRINT("info",("NodeId1=%d HostName1="%s"",id1,hostName1));
  3072.   DBUG_PRINT("info",("NodeId2=%d HostName2="%s"",id2,hostName2));
  3074.   if (id1 > id2) {
  3075.     Uint32 tmp= id1;
  3076.     const char *tmp_name= hostName1;
  3077.     hostName1= hostName2;
  3078.     id1= id2;
  3079.     hostName2= tmp_name;
  3080.     id2= tmp;
  3081.   }
  3083.   const Properties * node;
  3084.   require(ctx.m_config->get("Node", id1, &node));
  3085.   BaseString hostname(hostName1);
  3086.   //  require(node->get("HostName", hostname));
  3087.   
  3088.   if (hostname.c_str()[0] == 0) {
  3089.     ctx.reportError("Hostname required on nodeid %d since it will "
  3090.     "act as server.", id1);
  3091.     DBUG_RETURN(false);
  3092.   }
  3094.   Uint32 port= 0;
  3095.   if (!node->get("ServerPort", &port) &&
  3096.       !ctx.m_userProperties.get("ServerPort_", id1, &port)) {
  3097.     Uint32 adder= 0;
  3098.     {
  3099.       BaseString server_port_adder(hostname);
  3100.       server_port_adder.append("_ServerPortAdder");
  3101.       ctx.m_userProperties.get(server_port_adder.c_str(), &adder);
  3102.       ctx.m_userProperties.put(server_port_adder.c_str(), adder+1, true);
  3103.     }
  3105.     Uint32 base= 0;
  3106.     if (!ctx.m_userProperties.get("ServerPortBase", &base)){
  3107.       if(!(ctx.m_userDefaults &&
  3108.    ctx.m_userDefaults->get("PortNumber", &base)) &&
  3109.  !ctx.m_systemDefaults->get("PortNumber", &base)) {
  3110. base= strtoll(NDB_TCP_BASE_PORT,0,0);
  3111.       //      ctx.reportError("Cannot retrieve base port number");
  3112.       //      return false;
  3113.       }
  3114.       ctx.m_userProperties.put("ServerPortBase", base);
  3115.     }
  3116.     port= base + adder;
  3117.     ctx.m_userProperties.put("ServerPort_", id1, port);
  3118.   }
  3120.   if(ctx.m_currentSection->contains("PortNumber")) {
  3121.     ndbout << "PortNumber should no longer be specificied "
  3122.    << "per connection, please remove from config. "
  3123.    << "Will be changed to " << port << endl;
  3124.     ctx.m_currentSection->put("PortNumber", port, true);
  3125.   } 
  3126.   else
  3127.   {
  3128.     ctx.m_currentSection->put("PortNumber", port);
  3129.   }
  3130.   DBUG_PRINT("info", ("connection %d-%d port %d host %s",
  3131.       id1, id2, port, hostname.c_str()));
  3133.   DBUG_RETURN(true);
  3134. }
  3136. static bool 
  3137. fixShmUniqueId(InitConfigFileParser::Context & ctx, const char * data)
  3138. {
  3139.   DBUG_ENTER("fixShmUniqueId");
  3140.   Uint32 nodes= 0;
  3141.   ctx.m_userProperties.get(ctx.fname, &nodes);
  3142.   if (nodes == 1) // first management server
  3143.   {
  3144.     Uint32 portno= atoi(NDB_PORT);
  3145.     ctx.m_currentSection->get("PortNumber", &portno);
  3146.     ctx.m_userProperties.put("ShmUniqueId", portno);
  3147.   }
  3148.   DBUG_RETURN(true);
  3149. }
  3151. static 
  3152. bool 
  3153. fixShmKey(InitConfigFileParser::Context & ctx, const char *)
  3154. {
  3155.   DBUG_ENTER("fixShmKey");
  3156.   {
  3157.     static int last_signum= -1;
  3158.     Uint32 signum;
  3159.     if(!ctx.m_currentSection->get("Signum", &signum))
  3160.     {
  3161.       signum= OPT_NDB_SHM_SIGNUM_DEFAULT;
  3162.       if (signum <= 0)
  3163.       {
  3164.   ctx.reportError("Unable to set default parameter for [SHM]Signum"
  3165.   " please specify [SHM DEFAULT]Signum");
  3166.   return false;
  3167.       }
  3168.       ctx.m_currentSection->put("Signum", signum);
  3169.       DBUG_PRINT("info",("Added Signum=%u", signum));
  3170.     }
  3171.     if ( last_signum != (int)signum && last_signum >= 0 )
  3172.     {
  3173.       ctx.reportError("All shared memory transporters must have same [SHM]Signum defined."
  3174.       " Use [SHM DEFAULT]Signum");
  3175.       return false;
  3176.     }
  3177.     last_signum= (int)signum;
  3178.   }
  3179.   {
  3180.     Uint32 id1= 0, id2= 0, key= 0;
  3181.     require(ctx.m_currentSection->get("NodeId1", &id1));
  3182.     require(ctx.m_currentSection->get("NodeId2", &id2));
  3183.     if(!ctx.m_currentSection->get("ShmKey", &key))
  3184.     {
  3185.       require(ctx.m_userProperties.get("ShmUniqueId", &key));
  3186.       key= key << 16 | (id1 > id2 ? id1 << 8 | id2 : id2 << 8 | id1);
  3187.       ctx.m_currentSection->put("ShmKey", key);
  3188.       DBUG_PRINT("info",("Added ShmKey=0x%x", key));
  3189.     }
  3190.   }
  3191.   DBUG_RETURN(true);
  3192. }
  3194. /**
  3195.  * DB Node rule: Check various constraints
  3196.  */
  3197. static bool
  3198. checkDbConstraints(InitConfigFileParser::Context & ctx, const char *){
  3200.   Uint32 t1 = 0, t2 = 0;
  3201.   ctx.m_currentSection->get("MaxNoOfConcurrentOperations", &t1);
  3202.   ctx.m_currentSection->get("MaxNoOfConcurrentTransactions", &t2);
  3203.   
  3204.   if (t1 < t2) {
  3205.     ctx.reportError("MaxNoOfConcurrentOperations must be greater than "
  3206.     "MaxNoOfConcurrentTransactions - [%s] starting at line: %d",
  3207.     ctx.fname, ctx.m_sectionLineno);
  3208.     return false;
  3209.   }
  3211.   Uint32 replicas = 0, otherReplicas;
  3212.   ctx.m_currentSection->get("NoOfReplicas", &replicas);
  3213.   if(ctx.m_userProperties.get("NoOfReplicas", &otherReplicas)){
  3214.     if(replicas != otherReplicas){
  3215.       ctx.reportError("NoOfReplicas defined differently on different nodes"
  3216.       " - [%s] starting at line: %d",
  3217.       ctx.fname, ctx.m_sectionLineno);
  3218.       return false;
  3219.     }
  3220.   } else {
  3221.     ctx.m_userProperties.put("NoOfReplicas", replicas);
  3222.   }
  3223.   
  3224.   return true;
  3225. }
  3227. /**
  3228.  * Connection rule: Check varius constraints
  3229.  */
  3230. static bool
  3231. checkConnectionConstraints(InitConfigFileParser::Context & ctx, const char *){
  3233.   Uint32 id1 = 0, id2 = 0;
  3234.   ctx.m_currentSection->get("NodeId1", &id1);
  3235.   ctx.m_currentSection->get("NodeId2", &id2);
  3236.   
  3237.   // If external connection, just accept it
  3238.   if (ctx.m_currentSection->contains("System1") ||
  3239.       ctx.m_currentSection->contains("System2")) 
  3240.     return true;
  3242.   if(id1 == id2){
  3243.     ctx.reportError("Illegal connection from node to itself"
  3244.     " - [%s] starting at line: %d",
  3245.     ctx.fname, ctx.m_sectionLineno);
  3246.     return false;
  3247.   }
  3249.   const Properties * node1;
  3250.   if(!ctx.m_config->get("Node", id1, &node1)){
  3251.     ctx.reportError("Connection refering to undefined node: %d"
  3252.     " - [%s] starting at line: %d",
  3253.     id1, ctx.fname, ctx.m_sectionLineno);
  3254.     return false;
  3255.   }
  3257.   const Properties * node2;
  3258.   if(!ctx.m_config->get("Node", id2, &node2)){
  3259.     ctx.reportError("Connection refering to undefined node: %d"
  3260.     " - [%s] starting at line: %d",
  3261.     id2, ctx.fname, ctx.m_sectionLineno);
  3262.     return false;
  3263.   }
  3265.   const char * type1;
  3266.   const char * type2;
  3267.   require(node1->get("Type", &type1));
  3268.   require(node2->get("Type", &type2));
  3270.   /**
  3271.    * Report error if the following are true
  3272.    * -# None of the nodes is of type DB
  3273.    * -# Not both of them are MGMs
  3274.    * -# None of them contain a "SystemX" name
  3275.    */
  3276.   if((strcmp(type1, DB_TOKEN) != 0 && strcmp(type2, DB_TOKEN) != 0) &&
  3277.      !(strcmp(type1, MGM_TOKEN) == 0 && strcmp(type2, MGM_TOKEN) == 0) &&
  3278.      !ctx.m_currentSection->contains("System1") &&
  3279.      !ctx.m_currentSection->contains("System2")){
  3280.     ctx.reportError("Invalid connection between node %d (%s) and node %d (%s)"
  3281.     " - [%s] starting at line: %d",
  3282.     id1, type1, id2, type2, 
  3283.     ctx.fname, ctx.m_sectionLineno);
  3284.     return false;
  3285.   }
  3287.   return true;
  3288. }
  3290. static bool
  3291. checkTCPConstraints(InitConfigFileParser::Context & ctx, const char * data){
  3292.   
  3293.   const char * host;
  3294.   struct in_addr addr;
  3295.   if(ctx.m_currentSection->get(data, &host) && strlen(host) && 
  3296.      Ndb_getInAddr(&addr, host)){
  3297.     ctx.reportError("Unable to lookup/illegal hostname %s"
  3298.     " - [%s] starting at line: %d",
  3299.     host, ctx.fname, ctx.m_sectionLineno);
  3300.     return false;
  3301.   }
  3302.   return true;
  3303. }
  3305. static
  3306. bool
  3307. transform(InitConfigFileParser::Context & ctx,
  3308.   Properties & dst, 
  3309.   const char * oldName,
  3310.   const char * newName,
  3311.   double add, double mul){
  3312.   
  3313.   if(ctx.m_currentSection->contains(newName)){
  3314.     ctx.reportError("Both %s and %s specified"
  3315.     " - [%s] starting at line: %d",
  3316.     oldName, newName,
  3317.     ctx.fname, ctx.m_sectionLineno);
  3318.     return false;
  3319.   }
  3320.   
  3321.   PropertiesType oldType;
  3322.   require(ctx.m_currentSection->getTypeOf(oldName, &oldType));
  3323.   ConfigInfo::Type newType = ctx.m_info->getType(ctx.m_currentInfo, newName);  
  3324.   if(!((oldType == PropertiesType_Uint32 || oldType == PropertiesType_Uint64) 
  3325.        && (newType == ConfigInfo::CI_INT || newType == ConfigInfo::CI_INT64 || newType == ConfigInfo::CI_BOOL))){
  3326.     ndbout << "oldType: " << (int)oldType << ", newType: " << (int)newType << endl;
  3327.     ctx.reportError("Unable to handle type conversion w.r.t deprication %s %s"
  3328.     "- [%s] starting at line: %d",
  3329.     oldName, newName,
  3330.     ctx.fname, ctx.m_sectionLineno);
  3331.     return false;
  3332.   }
  3333.   Uint64 oldVal;
  3334.   require(ctx.m_currentSection->get(oldName, &oldVal));
  3336.   Uint64 newVal = (Uint64)((Int64)oldVal * mul + add);
  3337.   if(!ctx.m_info->verify(ctx.m_currentInfo, newName, newVal)){
  3338.     ctx.reportError("Unable to handle deprication, new value not within bounds"
  3339.     "%s %s - [%s] starting at line: %d",
  3340.     oldName, newName,
  3341.     ctx.fname, ctx.m_sectionLineno);
  3342.     return false;
  3343.   }
  3345.   if(newType == ConfigInfo::CI_INT || newType == ConfigInfo::CI_BOOL){
  3346.     require(dst.put(newName, (Uint32)newVal));
  3347.   } else if(newType == ConfigInfo::CI_INT64) {
  3348.     require(dst.put64(newName, newVal));    
  3349.   }
  3350.   return true;
  3351. }
  3353. static bool
  3354. fixDepricated(InitConfigFileParser::Context & ctx, const char * data){
  3355.   const char * name;
  3356.   /**
  3357.    * Transform old values to new values
  3358.    * Transform new values to old values (backward compatible)
  3359.    */
  3360.   Properties tmp(true);
  3361.   Properties::Iterator it(ctx.m_currentSection);
  3362.   for (name = it.first(); name != NULL; name = it.next()) {
  3363.     const DepricationTransform * p = &f_deprication[0];
  3364.     while(p->m_section != 0){
  3365.       if(strcmp(p->m_section, ctx.fname) == 0){
  3366. double mul = p->m_mul;
  3367. double add = p->m_add;
  3368. if(strcmp(name, p->m_oldName) == 0){
  3369.   if(!transform(ctx, tmp, name, p->m_newName, add, mul)){
  3370.     return false;
  3371.   }
  3372. } else if(strcmp(name, p->m_newName) == 0) {
  3373.   if(!transform(ctx, tmp, name, p->m_oldName, -add/mul,1.0/mul)){
  3374.     return false;
  3375.   }
  3376. }
  3377.       }
  3378.       p++;
  3379.     }
  3380.   }
  3381.   
  3382.   Properties::Iterator it2(&tmp);
  3383.   for (name = it2.first(); name != NULL; name = it2.next()) {
  3384.     PropertiesType type;
  3385.     require(tmp.getTypeOf(name, &type));
  3386.     switch(type){
  3387.     case PropertiesType_Uint32:{
  3388.       Uint32 val;
  3389.       require(tmp.get(name, &val));
  3390.       ::require(ctx.m_currentSection->put(name, val));
  3391.       break;
  3392.     }
  3393.     case PropertiesType_char:{
  3394.       const char * val;
  3395.       require(tmp.get(name, &val));
  3396.       ::require(ctx.m_currentSection->put(name, val));
  3397.       break;
  3398.     }
  3399.     case PropertiesType_Uint64:{
  3400.       Uint64 val;
  3401.       require(tmp.get(name, &val));
  3402.       ::require(ctx.m_currentSection->put64(name, val));
  3403.       break;
  3404.     }
  3405.     case PropertiesType_Properties:
  3406.     default:
  3407.       ::require(false);
  3408.     }
  3409.   }
  3410.   return true;
  3411. }
  3413. extern int g_print_full_config;
  3415. static bool
  3416. saveInConfigValues(InitConfigFileParser::Context & ctx, const char * data){
  3417.   const Properties * sec;
  3418.   if(!ctx.m_currentInfo->get(ctx.fname, &sec)){
  3419.     require(false);
  3420.     return false;
  3421.   }
  3422.   
  3423.   do {
  3424.     const char *secName;
  3425.     Uint32 id, status, typeVal;
  3426.     require(sec->get("Fname", &secName));
  3427.     require(sec->get("Id", &id));
  3428.     require(sec->get("Status", &status));
  3429.     require(sec->get("SectionType", &typeVal));
  3430.     
  3431.     if(id == KEY_INTERNAL || status == ConfigInfo::CI_INTERNAL){
  3432.       ndbout_c("skipping section %s", ctx.fname);
  3433.       break;
  3434.     }
  3435.     
  3436.     if (g_print_full_config)
  3437.     {
  3438.       const char *alias= ConfigInfo::nameToAlias(ctx.fname);
  3439.       printf("[%s]n", alias ? alias : ctx.fname);
  3440.     }
  3442.     Uint32 no = 0;
  3443.     ctx.m_userProperties.get("$Section", id, &no);
  3444.     ctx.m_userProperties.put("$Section", id, no+1, true);
  3445.     
  3446.     ctx.m_configValues.openSection(id, no);
  3447.     ctx.m_configValues.put(CFG_TYPE_OF_SECTION, typeVal);
  3448.     
  3449.     Properties::Iterator it(ctx.m_currentSection);
  3450.     for (const char* n = it.first(); n != NULL; n = it.next()) {
  3451.       const Properties * info;
  3452.       if(!ctx.m_currentInfo->get(n, &info))
  3453. continue;
  3455.       Uint32 id = 0;
  3456.       info->get("Id", &id);
  3457.       
  3458.       if(id == KEY_INTERNAL)
  3459. continue;
  3461.       bool ok = true;
  3462.       PropertiesType type;
  3463.       require(ctx.m_currentSection->getTypeOf(n, &type));
  3464.       switch(type){
  3465.       case PropertiesType_Uint32:{
  3466. Uint32 val;
  3467. require(ctx.m_currentSection->get(n, &val));
  3468. ok = ctx.m_configValues.put(id, val);
  3469. if (g_print_full_config)
  3470.   printf("%s=%un", n, val);
  3471. break;
  3472.       }
  3473.       case PropertiesType_Uint64:{
  3474. Uint64 val;
  3475. require(ctx.m_currentSection->get(n, &val));
  3476. ok = ctx.m_configValues.put64(id, val);
  3477. if (g_print_full_config)
  3478.   printf("%s=%llun", n, val);
  3479. break;
  3480.       }
  3481.       case PropertiesType_char:{
  3482. const char * val;
  3483. require(ctx.m_currentSection->get(n, &val));
  3484. ok = ctx.m_configValues.put(id, val);
  3485. if (g_print_full_config)
  3486.   printf("%s=%sn", n, val);
  3487. break;
  3488.       }
  3489.       default:
  3490. require(false);
  3491.       }
  3492.       require(ok);
  3493.     }
  3494.     ctx.m_configValues.closeSection();
  3495.   } while(0);
  3496.   return true;
  3497. }
  3499. static bool
  3500. sanity_checks(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  3501.       struct InitConfigFileParser::Context &ctx, 
  3502.       const char * rule_data)
  3503. {
  3504.   Uint32 db_nodes = 0;
  3505.   Uint32 mgm_nodes = 0;
  3506.   Uint32 api_nodes = 0;
  3507.   if (!ctx.m_userProperties.get("DB", &db_nodes)) {
  3508.     ctx.reportError("At least one database node should be defined in config file");
  3509.     return false;
  3510.   }
  3511.   if (!ctx.m_userProperties.get("MGM", &mgm_nodes)) {
  3512.     ctx.reportError("At least one management server node should be defined in config file");
  3513.     return false;
  3514.   }
  3515.   if (!ctx.m_userProperties.get("API", &api_nodes)) {
  3516.     ctx.reportError("At least one application node (for the mysqld) should be defined in config file");
  3517.     return false;
  3518.   }
  3519.   return true;
  3520. }
  3522. static void
  3523. add_a_connection(Vector<ConfigInfo::ConfigRuleSection>&sections,
  3524.  struct InitConfigFileParser::Context &ctx,
  3525.  Uint32 nodeId1, Uint32 nodeId2, bool use_shm)
  3526. {
  3527.   ConfigInfo::ConfigRuleSection s;
  3528.   const char *hostname1= 0, *hostname2= 0;
  3529.   const Properties *tmp;
  3530.   
  3531.   require(ctx.m_config->get("Node", nodeId1, &tmp));
  3532.   tmp->get("HostName", &hostname1);
  3533.   
  3534.   require(ctx.m_config->get("Node", nodeId2, &tmp));
  3535.   tmp->get("HostName", &hostname2);
  3536.   
  3537.   char buf[16];
  3538.   s.m_sectionData= new Properties(true);
  3539.   BaseString::snprintf(buf, sizeof(buf), "%u", nodeId1);
  3540.   s.m_sectionData->put("NodeId1", buf);
  3541.   BaseString::snprintf(buf, sizeof(buf), "%u", nodeId2);
  3542.   s.m_sectionData->put("NodeId2", buf);
  3544.   if (use_shm &&
  3545.       hostname1 && hostname1[0] &&
  3546.       hostname2 && hostname2[0] &&
  3547.       strcmp(hostname1,hostname2) == 0)
  3548.   {
  3549.     s.m_sectionType= BaseString("SHM");
  3550.     DBUG_PRINT("info",("adding SHM connection %d %d",nodeId1,nodeId2));
  3551.   }
  3552.   else
  3553.   {
  3554.     s.m_sectionType= BaseString("TCP");
  3555.     DBUG_PRINT("info",("adding TCP connection %d %d",nodeId1,nodeId2));
  3556.   }
  3558.   sections.push_back(s);
  3559. }
  3561. static bool
  3562. add_node_connections(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  3563.    struct InitConfigFileParser::Context &ctx, 
  3564.    const char * rule_data)
  3565. {
  3566.   DBUG_ENTER("add_node_connections");
  3567.   Uint32 i;
  3568.   Properties * props= ctx.m_config;
  3569.   Properties p_connections(true);
  3570.   Properties p_connections2(true);
  3572.   for (i = 0;; i++){
  3573.     const Properties * tmp;
  3574.     Uint32 nodeId1, nodeId2;
  3576.     if(!props->get("Connection", i, &tmp)) break;
  3578.     if(!tmp->get("NodeId1", &nodeId1)) continue;
  3579.     p_connections.put("", nodeId1, nodeId1);
  3580.     if(!tmp->get("NodeId2", &nodeId2)) continue;
  3581.     p_connections.put("", nodeId2, nodeId2);
  3583.     p_connections2.put("", nodeId1 + nodeId2<<16, nodeId1);
  3584.     p_connections2.put("", nodeId2 + nodeId1<<16, nodeId2);
  3585.   }
  3587.   Uint32 nNodes;
  3588.   ctx.m_userProperties.get("NoOfNodes", &nNodes);
  3590.   Properties p_db_nodes(true);
  3591.   Properties p_api_nodes(true);
  3592.   Properties p_mgm_nodes(true);
  3594.   Uint32 i_db= 0, i_api= 0, i_mgm= 0, n;
  3595.   for (i= 0, n= 0; n < nNodes; i++){
  3596.     const Properties * tmp;
  3597.     if(!props->get("Node", i, &tmp)) continue;
  3598.     n++;
  3600.     const char * type;
  3601.     if(!tmp->get("Type", &type)) continue;
  3603.     if (strcmp(type,DB_TOKEN) == 0)
  3604.       p_db_nodes.put("", i_db++, i);
  3605.     else if (strcmp(type,API_TOKEN) == 0)
  3606.       p_api_nodes.put("", i_api++, i);
  3607.     else if (strcmp(type,MGM_TOKEN) == 0)
  3608.       p_mgm_nodes.put("", i_mgm++, i);
  3609.   }
  3611.   Uint32 nodeId1, nodeId2, dummy;
  3613.   for (i= 0; p_db_nodes.get("", i, &nodeId1); i++){
  3614.     for (Uint32 j= i+1;; j++){
  3615.       if(!p_db_nodes.get("", j, &nodeId2)) break;
  3616.       if(!p_connections2.get("", nodeId1+nodeId2<<16, &dummy)) {
  3617. add_a_connection(sections,ctx,nodeId1,nodeId2,opt_ndb_shm);
  3618.       }
  3619.     }
  3620.   }
  3622.   for (i= 0; p_api_nodes.get("", i, &nodeId1); i++){
  3623.     if(!p_connections.get("", nodeId1, &dummy)) {
  3624.       for (Uint32 j= 0;; j++){
  3625. if(!p_db_nodes.get("", j, &nodeId2)) break;
  3626. add_a_connection(sections,ctx,nodeId1,nodeId2,opt_ndb_shm);
  3627.       }
  3628.     }
  3629.   }
  3631.   for (i= 0; p_mgm_nodes.get("", i, &nodeId1); i++){
  3632.     if(!p_connections.get("", nodeId1, &dummy)) {
  3633.       for (Uint32 j= 0;; j++){
  3634. if(!p_db_nodes.get("", j, &nodeId2)) break;
  3635. add_a_connection(sections,ctx,nodeId1,nodeId2,0);
  3636.       }
  3637.     }
  3638.   }
  3640.   DBUG_RETURN(true);
  3641. }
  3643. static bool set_connection_priorities(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  3644.  struct InitConfigFileParser::Context &ctx, 
  3645.  const char * rule_data)
  3646. {
  3647.   DBUG_ENTER("set_connection_priorities");
  3648.   DBUG_RETURN(true);
  3649. }
  3651. static bool add_server_ports(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  3652.       struct InitConfigFileParser::Context &ctx, 
  3653.       const char * rule_data)
  3654. {
  3655. #if 0
  3656.   Properties * props= ctx.m_config;
  3657.   Properties computers(true);
  3658.   Uint32 port_base = NDB_TCP_BASE_PORT;
  3660.   Uint32 nNodes;
  3661.   ctx.m_userProperties.get("NoOfNodes", &nNodes);
  3663.   for (Uint32 i= 0, n= 0; n < nNodes; i++){
  3664.     Properties * tmp;
  3665.     if(!props->get("Node", i, &tmp)) continue;
  3666.     n++;
  3668.     const char * type;
  3669.     if(!tmp->get("Type", &type)) continue;
  3671.     Uint32 port;
  3672.     if (tmp->get("ServerPort", &port)) continue;
  3674.     Uint32 computer;
  3675.     if (!tmp->get("ExecuteOnComputer", &computer)) continue;
  3677.     Uint32 adder= 0;
  3678.     computers.get("",computer, &adder);
  3680.     if (strcmp(type,DB_TOKEN) == 0) {
  3681.       adder++;
  3682.       tmp->put("ServerPort", port_base+adder);
  3683.       computers.put("",computer, adder);
  3684.     }
  3685.   }
  3686. #endif
  3687.   return true;
  3688. }
  3690. static bool
  3691. check_node_vs_replicas(Vector<ConfigInfo::ConfigRuleSection>&sections, 
  3692.        struct InitConfigFileParser::Context &ctx, 
  3693.        const char * rule_data)
  3694. {
  3695.   Uint32 db_nodes= 0;
  3696.   Uint32 replicas= 0;
  3697.   Uint32 db_host_count= 0;
  3698.   ctx.m_userProperties.get(DB_TOKEN, &db_nodes);
  3699.   ctx.m_userProperties.get("NoOfReplicas", &replicas);
  3700.   if((db_nodes % replicas) != 0){
  3701.     ctx.reportError("Invalid no of db nodes wrt no of replicas.n"
  3702.     "No of nodes must be dividable with no or replicas");
  3703.     return false;
  3704.   }
  3705.   // check that node groups and arbitrators are ok
  3706.   // just issue warning if not
  3707.   if(replicas > 1){
  3708.     Properties * props= ctx.m_config;
  3709.     Properties p_db_hosts(true); // store hosts which db nodes run on
  3710.     Properties p_arbitrators(true); // store hosts which arbitrators run on
  3711.     // arbitrator should not run together with db node on same host
  3712.     Uint32 i, n, group= 0, i_group= 0;
  3713.     Uint32 n_nodes;
  3714.     BaseString node_group_warning, arbitration_warning;
  3715.     const char *arbit_warn_fmt=
  3716.       "n  arbitrator with id %d and db node with id %d on same host %s";
  3717.     const char *arbit_warn_fmt2=
  3718.       "n  arbitrator with id %d has no hostname specified";
  3720.     ctx.m_userProperties.get("NoOfNodes", &n_nodes);
  3721.     for (i= 0, n= 0; n < n_nodes; i++){
  3722.       const Properties * tmp;
  3723.       if(!props->get("Node", i, &tmp)) continue;
  3724.       n++;
  3726.       const char * type;
  3727.       if(!tmp->get("Type", &type)) continue;
  3729.       const char* host= 0;
  3730.       tmp->get("HostName", &host);
  3732.       if (strcmp(type,DB_TOKEN) == 0)
  3733.       {
  3734. {
  3735.   Uint32 ii;
  3736.   if (!p_db_hosts.get(host,&ii))
  3737.     db_host_count++;
  3738.   p_db_hosts.put(host,i);
  3739.   if (p_arbitrators.get(host,&ii))
  3740.   {
  3741.     arbitration_warning.appfmt(arbit_warn_fmt, ii, i, host);
  3742.     p_arbitrators.remove(host); // only one warning per db node
  3743.   }
  3744. }
  3745. {
  3746.   unsigned j;
  3747.   BaseString str, str2;
  3748.   str.assfmt("#group%d_",group);
  3749.   p_db_hosts.put(str.c_str(),i_group,host);
  3750.   str2.assfmt("##group%d_",group);
  3751.   p_db_hosts.put(str2.c_str(),i_group,i);
  3752.   for (j= 0; j < i_group; j++)
  3753.   {
  3754.     const char *other_host;
  3755.     p_db_hosts.get(str.c_str(),j,&other_host);
  3756.     if (strcmp(host,other_host) == 0) {
  3757.       unsigned int other_i, c= 0;
  3758.       p_db_hosts.get(str2.c_str(),j,&other_i);
  3759.       p_db_hosts.get(str.c_str(),&c);
  3760.       if (c == 0) // first warning in this node group
  3761. node_group_warning.appfmt("  Node group %d", group);
  3762.       c|= 1 << j;
  3763.       p_db_hosts.put(str.c_str(),c);
  3765.       node_group_warning.appfmt(",n    db node with id %d and id %d "
  3766. "on same host %s", other_i, i, host);
  3767.     }
  3768.   }
  3769.   i_group++;
  3770.   DBUG_ASSERT(i_group <= replicas);
  3771.   if (i_group == replicas)
  3772.   {
  3773.     unsigned c= 0;
  3774.     p_db_hosts.get(str.c_str(),&c);
  3775.     if (c+1 == (1u << (replicas-1))) // all nodes on same machine
  3776.       node_group_warning.append(".n    Host failure will "
  3777. "cause complete cluster shutdown.");
  3778.     else if (c > 0)
  3779.       node_group_warning.append(".n    Host failure may "
  3780. "cause complete cluster shutdown.");
  3781.     group++;
  3782.     i_group= 0;
  3783.   }
  3784. }
  3785.       }
  3786.       else if (strcmp(type,API_TOKEN) == 0 ||
  3787.        strcmp(type,MGM_TOKEN) == 0)
  3788.       {
  3789. Uint32 rank;
  3790. if(tmp->get("ArbitrationRank", &rank) && rank > 0)
  3791. {
  3792.   if(host && host[0] != 0)
  3793.   {
  3794.     Uint32 ii;
  3795.     p_arbitrators.put(host,i);
  3796.     if (p_db_hosts.get(host,&ii))
  3797.     {
  3798.       arbitration_warning.appfmt(arbit_warn_fmt, i, ii, host);
  3799.     }
  3800.   }
  3801.   else
  3802.   {
  3803.     arbitration_warning.appfmt(arbit_warn_fmt2, i);
  3804.   }
  3805. }
  3806.       }
  3807.     }
  3808.     if (db_host_count > 1 && node_group_warning.length() > 0)
  3809.       ndbout_c("Cluster configuration warning:n%s",node_group_warning.c_str());
  3810.     if (db_host_count > 1 && arbitration_warning.length() > 0)
  3811.       ndbout_c("Cluster configuration warning:%s%s",arbitration_warning.c_str(),
  3812.        "n  Running arbitrator on the same host as a database node may"
  3813.        "n  cause complete cluster shutdown in case of host failure.");
  3814.   }
  3815.   return true;
  3816. }
  3818. template class Vector<ConfigInfo::ConfigRuleSection>;