1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge tulin@bk-internal.mysql.com:/home/bk/mysql-4.1

Browse Source 
into poseidon.(none):/home/tomas/mysql-4.1-clean
This commit is contained in:
tomas@poseidon.(none) 2004-08-24 20:37:03 +00:00
commit c81df5a0ae
6 changed files with 102 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
mysql-test/ndb/ndb_config_2_node.ini
View File

@ -24,13 +24,13 @@ ExecuteOnComputer: 2
[MGM]
PortNumber: CHOOSE_PORT_MGM
[API]
[MYSQLD]
[API]
[MYSQLD]
[API]
[MYSQLD]
[API]
[MYSQLD]
[TCP DEFAULT]
PortNumber: CHOOSE_PORT_TRANSPORTER

2
ndb/include/util/Properties.hpp
View File

@ -55,7 +55,7 @@ public:
static const char delimiter = ':';
static const char version[];
Properties();
Properties(bool case_insensitive= false);
Properties(const Properties &);
Properties(const Property *, int len);
virtual ~Properties();

60
ndb/src/common/mgmcommon/ConfigInfo.cpp
View File

@ -25,6 +25,13 @@
/****************************************************************************
* Section names
****************************************************************************/
const ConfigInfo::AliasPair
ConfigInfo::m_sectionNameAliases[]={
{"API", "MYSQLD"},
{0, 0}
};
const char*
ConfigInfo::m_sectionNames[]={
"SYSTEM",
@ -153,14 +160,14 @@ const int ConfigInfo::m_NoOfRules = sizeof(m_SectionRules)/sizeof(SectionRule);
* Config Rules declarations
****************************************************************************/
static bool add_node_connections(Vector<ConfigInfo::ConfigRuleSection>&sections,
struct InitConfigFileParser::Context &ctx,
const char * rule_data);
struct InitConfigFileParser::Context &ctx,
const char * rule_data);
static bool add_server_ports(Vector<ConfigInfo::ConfigRuleSection>&sections,
struct InitConfigFileParser::Context &ctx,
const char * rule_data);
struct InitConfigFileParser::Context &ctx,
const char * rule_data);
static bool check_node_vs_replicas(Vector<ConfigInfo::ConfigRuleSection>&sections,
struct InitConfigFileParser::Context &ctx,
const char * rule_data);
struct InitConfigFileParser::Context &ctx,
const char * rule_data);
const ConfigInfo::ConfigRule
ConfigInfo::m_ConfigRules[] = {
@ -432,7 +439,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
8192,
0,
MAX_INT_RNIL
},
},
{
CFG_DB_NO_TRIGGERS,
@ -1885,21 +1892,19 @@ const int ConfigInfo::m_NoOfParams = sizeof(m_ParamInfo) / sizeof(ParamInfo);
****************************************************************************/
static void require(bool v) { if(!v) abort();}
ConfigInfo::ConfigInfo() {
ConfigInfo::ConfigInfo()
: m_info(true), m_systemDefaults(true)
{
int i;
Properties *section;
const Properties *oldpinfo;
m_info.setCaseInsensitiveNames(true);
m_systemDefaults.setCaseInsensitiveNames(true);
for (i=0; i<m_NoOfParams; i++) {
const ParamInfo & param = m_ParamInfo[i];
// Create new section if it did not exist
if (!m_info.getCopy(param._section, &section)) {
Properties newsection;
newsection.setCaseInsensitiveNames(true);
Properties newsection(true);
m_info.put(param._section, &newsection);
}
@ -1907,7 +1912,7 @@ ConfigInfo::ConfigInfo() {
m_info.getCopy(param._section, &section);
// Create pinfo (parameter info) entry
Properties pinfo;
Properties pinfo(true);
pinfo.put("Id", param._paramId);
pinfo.put("Fname", param._fname);
pinfo.put("Description", param._description);
@ -1935,8 +1940,7 @@ ConfigInfo::ConfigInfo() {
if(param._type != ConfigInfo::SECTION){
Properties * p;
if(!m_systemDefaults.getCopy(param._section, &p)){
p = new Properties();
p->setCaseInsensitiveNames(true);
p = new Properties(true);
}
if(param._type != STRING &&
param._default != UNDEFINED &&
@ -2063,6 +2067,14 @@ ConfigInfo::isSection(const char * section) const {
return false;
}
const char*
ConfigInfo::getAlias(const char * section) const {
for (int i = 0; m_sectionNameAliases[i].name != 0; i++)
if(!strcmp(section, m_sectionNameAliases[i].alias))
return m_sectionNameAliases[i].name;
return 0;
}
bool
ConfigInfo::verify(const Properties * section, const char* fname,
Uint64 value) const {
@ -2819,7 +2831,7 @@ fixDepricated(InitConfigFileParser::Context & ctx, const char * data){
* Transform old values to new values
* Transform new values to old values (backward compatible)
*/
Properties tmp;
Properties tmp(true);
Properties::Iterator it(ctx.m_currentSection);
for (name = it.first(); name != NULL; name = it.next()) {
const DepricationTransform * p = &f_deprication[0];
@ -2951,8 +2963,8 @@ add_node_connections(Vector<ConfigInfo::ConfigRuleSection>&sections,
{
Uint32 i;
Properties * props= ctx.m_config;
Properties p_connections;
Properties p_connections2;
Properties p_connections(true);
Properties p_connections2(true);
for (i = 0;; i++){
const Properties * tmp;
@ -2972,8 +2984,8 @@ add_node_connections(Vector<ConfigInfo::ConfigRuleSection>&sections,
Uint32 nNodes;
ctx.m_userProperties.get("NoOfNodes", &nNodes);
Properties p_db_nodes;
Properties p_api_mgm_nodes;
Properties p_db_nodes(true);
Properties p_api_mgm_nodes(true);
Uint32 i_db= 0, i_api_mgm= 0, n;
for (i= 0, n= 0; n < nNodes; i++){
@ -2999,7 +3011,7 @@ add_node_connections(Vector<ConfigInfo::ConfigRuleSection>&sections,
if(!p_connections2.get("", nodeId1+nodeId2<<16, &dummy)) {
ConfigInfo::ConfigRuleSection s;
s.m_sectionType= BaseString("TCP");
s.m_sectionData= new Properties;
s.m_sectionData= new Properties(true);
char buf[16];
snprintf(buf, sizeof(buf), "%u", nodeId1);
s.m_sectionData->put("NodeId1", buf);
@ -3016,7 +3028,7 @@ add_node_connections(Vector<ConfigInfo::ConfigRuleSection>&sections,
if(!p_db_nodes.get("", j, &nodeId2)) break;
ConfigInfo::ConfigRuleSection s;
s.m_sectionType= BaseString("TCP");
s.m_sectionData= new Properties;
s.m_sectionData= new Properties(true);
char buf[16];
snprintf(buf, sizeof(buf), "%u", nodeId1);
s.m_sectionData->put("NodeId1", buf);
@ -3037,7 +3049,7 @@ static bool add_server_ports(Vector<ConfigInfo::ConfigRuleSection>&sections,
{
#if 0
Properties * props= ctx.m_config;
Properties computers;
Properties computers(true);
Uint32 port_base = NDB_BASE_PORT+2;
Uint32 nNodes;

7
ndb/src/common/mgmcommon/ConfigInfo.hpp
View File

@ -61,6 +61,11 @@ public:
Uint64 _max;
};
struct AliasPair{
const char * name;
const char * alias;
};
/**
* Entry for one section rule
*/
@ -100,6 +105,7 @@ public:
* @note Result is not defined if section/name are wrong!
*/
bool verify(const Properties* secti, const char* fname, Uint64 value) const;
const char* getAlias(const char*) const;
bool isSection(const char*) const;
const char* getDescription(const Properties * sec, const char* fname) const;
@ -123,6 +129,7 @@ private:
static const ParamInfo m_ParamInfo[];
static const int m_NoOfParams;
static const AliasPair m_sectionNameAliases[];
static const char* m_sectionNames[];
static const int m_noOfSectionNames;

43
ndb/src/common/mgmcommon/InitConfigFileParser.cpp
View File

@ -43,10 +43,10 @@ InitConfigFileParser::~InitConfigFileParser() {
// Read Config File
//****************************************************************************
InitConfigFileParser::Context::Context(const ConfigInfo * info)
: m_configValues(1000, 20) {
: m_configValues(1000, 20), m_userProperties(true) {
m_config = new Properties();
m_defaults = new Properties();
m_config = new Properties(true);
m_defaults = new Properties(true);
}
InitConfigFileParser::Context::~Context(){
@ -115,7 +115,7 @@ InitConfigFileParser::parseConfig(FILE * file) {
snprintf(ctx.fname, sizeof(ctx.fname), section); free(section);
ctx.type = InitConfigFileParser::DefaultSection;
ctx.m_sectionLineno = ctx.m_lineno;
ctx.m_currentSection = new Properties();
ctx.m_currentSection = new Properties(true);
ctx.m_userDefaults = NULL;
ctx.m_currentInfo = m_info->getInfo(ctx.fname);
ctx.m_systemDefaults = m_info->getDefaults(ctx.fname);
@ -137,7 +137,7 @@ InitConfigFileParser::parseConfig(FILE * file) {
free(section);
ctx.type = InitConfigFileParser::Section;
ctx.m_sectionLineno = ctx.m_lineno;
ctx.m_currentSection = new Properties();
ctx.m_currentSection = new Properties(true);
ctx.m_userDefaults = getSection(ctx.fname, ctx.m_defaults);
ctx.m_currentInfo = m_info->getInfo(ctx.fname);
ctx.m_systemDefaults = m_info->getDefaults(ctx.fname);
@ -222,6 +222,8 @@ bool InitConfigFileParser::parseNameValuePair(Context& ctx, const char* line) {
char tmpLine[MAX_LINE_LENGTH];
char fname[MAX_LINE_LENGTH], rest[MAX_LINE_LENGTH];
char* t;
const char *separator_list[]= {":", "="};
const char *separator= 0;
if (ctx.m_currentSection == NULL){
ctx.reportError("Value specified outside section");
@ -233,7 +235,14 @@ bool InitConfigFileParser::parseNameValuePair(Context& ctx, const char* line) {
// *************************************
// Check if a separator exists in line
// *************************************
if (!strchr(tmpLine, ':')) {
for(int i= 0; i < sizeof(separator_list); i++) {
if(strchr(tmpLine, separator_list[i][0])) {
separator= separator_list[i];
break;
}
}
if (separator == 0) {
ctx.reportError("Parse error");
return false;
}
@ -241,13 +250,13 @@ bool InitConfigFileParser::parseNameValuePair(Context& ctx, const char* line) {
// *******************************************
// Get pointer to substring before separator
// *******************************************
t = strtok(tmpLine, ":");
t = strtok(tmpLine, separator);
// *****************************************
// Count number of tokens before separator
// *****************************************
if (sscanf(t, "%120s%120s", fname, rest) != 1) {
ctx.reportError("Multiple names before \':\'");
ctx.reportError("Multiple names before \'%c\'", separator[0]);
return false;
}
if (!ctx.m_currentInfo->contains(fname)) {
@ -475,8 +484,24 @@ InitConfigFileParser::parseSectionHeader(const char* line) const {
tmp[0] = ' ';
trim(tmp);
// Convert section header to upper
for(int i= strlen(tmp)-1; i >= 0; i--)
tmp[i]= toupper(tmp[i]);
// Get the correct header name if an alias
{
const char *tmp_alias= m_info->getAlias(tmp);
if (tmp_alias) {
free(tmp);
tmp= strdup(tmp_alias);
}
}
// Lookup token among sections
if(!m_info->isSection(tmp)) return NULL;
if(!m_info->isSection(tmp)) {
free(tmp);
return NULL;
}
if(m_info->getInfo(tmp)) return tmp;
free(tmp);

33
ndb/src/common/util/Properties.cpp
View File

@ -56,7 +56,7 @@ class PropertiesImpl {
PropertiesImpl(const PropertiesImpl &); // Not implemented
PropertiesImpl& operator=(const PropertiesImpl&); // Not implemented
public:
PropertiesImpl(Properties *);
PropertiesImpl(Properties *, bool case_insensitive);
PropertiesImpl(Properties *, const PropertiesImpl &);
~PropertiesImpl();
@ -69,6 +69,7 @@ public:
bool m_insensitive;
int (* compare)(const char *s1, const char *s2);
void setCaseInsensitiveNames(bool value);
void grow(int sizeToAdd);
PropertyImpl * get(const char * name) const;
@ -113,9 +114,9 @@ Property::~Property(){
/**
* Methods for Properties
*/
Properties::Properties(){
Properties::Properties(bool case_insensitive){
parent = 0;
impl = new PropertiesImpl(this);
impl = new PropertiesImpl(this, case_insensitive);
}
Properties::Properties(const Properties & org){
@ -124,7 +125,7 @@ Properties::Properties(const Properties & org){
}
Properties::Properties(const Property * anArray, int arrayLen){
impl = new PropertiesImpl(this);
impl = new PropertiesImpl(this, false);
put(anArray, arrayLen);
}
@ -479,13 +480,12 @@ Properties::unpack(const Uint32 * buf, Uint32 bufLen){
/**
* Methods for PropertiesImpl
*/
PropertiesImpl::PropertiesImpl(Properties * p){
PropertiesImpl::PropertiesImpl(Properties * p, bool case_insensitive){
this->properties = p;
items = 0;
size = 25;
content = new PropertyImpl * [size];
this->m_insensitive = false;
this->compare = strcmp;
setCaseInsensitiveNames(case_insensitive);
}
PropertiesImpl::PropertiesImpl(Properties * p, const PropertiesImpl & org){
@ -506,6 +506,15 @@ PropertiesImpl::~PropertiesImpl(){
delete [] content;
}
void
PropertiesImpl::setCaseInsensitiveNames(bool value){
m_insensitive = value;
if(value)
compare = strcasecmp;
else
compare = strcmp;
}
void
PropertiesImpl::grow(int sizeToAdd){
PropertyImpl ** newContent = new PropertyImpl * [size + sizeToAdd];
@ -523,9 +532,11 @@ PropertiesImpl::get(const char * name) const {
return 0;
}
for(unsigned int i = 0; i<tmp->items; i++)
for(unsigned int i = 0; i<tmp->items; i++) {
if((* compare)(tmp->content[i]->name, short_name) == 0)
return tmp->content[i];
}
return 0;
}
@ -1110,11 +1121,7 @@ Properties::getCopy(const char * name, Uint32 no, Properties ** value) const {
void
Properties::setCaseInsensitiveNames(bool value){
impl->m_insensitive = value;
if(value)
impl->compare = strcasecmp;
else
impl->compare = strcmp;
impl->setCaseInsensitiveNames(value);
}
bool