src/storage/Config.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.com                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #include<Config.h>
  17 #include<ErrorType.h>
  18 #include<Debug.h>
  19
  20 Config Conf::config;
  21
  22 int Config::readLine(FILE *fp, char * buffer)
  23 {
  24   char c =0;
  25   int count =0;
  26   while (true)
  27   {
  28       c = fgetc(fp);
  29       if (c == '\n') break;
  30       if (c == EOF) return EOF;
  31       buffer[count++] = c;
  32   }
  33   return count;
  34 }
  35 int Config::storeKeyVal(char *key, char *value)
  36 {
  37     if (os::os::strcasestr(key, "PAGE_SIZE") != NULL )
  38            { cVal.pageSize = atoi(value);  }
  39     else if (os::strcasestr(key, "MAX_PROCS") != NULL)
  40            { cVal.maxProcs = atoi(value);  }
  41     else if (os::strcasestr(key, "MAX_SYS_DB_SIZE") != NULL)
  42            { cVal.maxSysSize = atol(value);  }
  43     else if (os::strcasestr(key, "MAX_DB_SIZE") != NULL)
  44            { cVal.maxDbSize = atol(value);  }
  45     else if (os::strcasestr(key, "MMAP") != NULL)
  46            { cVal.mmap = os::atobool(value);  }
  47     else if (os::strcasestr(key, "SYS_DB_KEY") != NULL)
  48            { cVal.sysDbKey = atoi(value);  }
  49     else if (os::strcasestr(key, "USER_DB_KEY") != NULL)
  50            { cVal.userDbKey = atoi(value);  }
  51     else if (os::strcasestr(key, "LOG_FILE") != NULL)
  52            { strcpy(cVal.logFile , value);  }
  53     else if (os::strcasestr(key, "DATABASE_FILE") != NULL)
  54            { strcpy(cVal.dbFile , value);  }
  55     else if (os::strcasestr(key, "MAP_ADDRESS") != NULL)
  56            { cVal.mapAddr = atol(value);  }
  57     else if (os::strcasestr(key, "MUTEX_TIMEOUT_SECS") != NULL)
  58            { cVal.mutexSecs = atoi(value);  }
  59     else if (os::strcasestr(key, "MUTEX_TIMEOUT_USECS") != NULL)
  60            { cVal.mutexUSecs = atoi(value);  }
  61     else if (os::strcasestr(key, "MUTEX_TIMEOUT_RETRIES") != NULL)
  62            { cVal.mutexRetries = atoi(value);  }
  63     else if (os::strcasestr(key, "LOCK_TIMEOUT_SECS") != NULL)
  64            { cVal.lockSecs = atoi(value);  }
  65     else if (os::strcasestr(key, "LOCK_TIMEOUT_USECS") != NULL)
  66            { cVal.lockUSecs = atoi(value);  }
  67     else if (os::strcasestr(key, "LOCK_TIMEOUT_RETRIES") != NULL)
  68            { cVal.lockRetries = atoi(value);  }
  69     else if (os::strcasestr(key, "LOG_LEVEL") != NULL)
  70            { cVal.logLevel = atoi(value);  }
  71     else if (os::strcasestr(key, "DSN") != NULL)
  72            { strcpy(cVal.dsn , value);  }
  73     else if (os::strcasestr(key, "NO_OF_ROWS_TO_FETCH") != NULL)
  74            { cVal.nRowsToFetch = atoi(value);  }
  75     else if (os::strcasestr(key,"DS_CONFIG_FILE") !=NULL)
  76            { strcpy(cVal.dsConfigFile,value);}
  77     else if (os::strcasestr(key, "TABLE_CONFIG_FILE") != NULL)
  78            { strcpy(cVal.tableConfigFile , value);  }
  79     else if (os::strcasestr(key, "STDERR_FILE") != NULL)
  80            { strcpy(cVal.stderrFile, value);  }
  81     else if (os::strcasestr(key, "CONFL_RESOL_FILE") != NULL)
  82            { strcpy(cVal.conflResoFile , value);  }
  83     else if (os::strcasestr(key, "CACHE_TABLE") != NULL)
  84            { cVal.isCache = os::atobool(value); }
  85     else if (os::strcasestr(key, "CACHE_MODE") != NULL)
  86            {
  87                if (strcmp(value, "SYNC") == 0)
  88                {    cVal.mode = SYNC_MODE;    }
  89                else if (strcmp(value, "ASYNC") == 0)
  90                {    cVal.mode = ASYNC_MODE;   }
  91                else if (strcmp(value, "OFFLINE") == 0)
  92                {    cVal.mode = OFFLINE_MODE;   }
  93                else cVal.mode = UNKNOWN;
  94            }
  95     else if (os::strcasestr(key, "OFFLINE_FILE_SIZE") != NULL)
  96        { cVal.offlineLogFileSize = atol(value); }
  97     else if(os::strcasestr(key,"SITE_ID")!=NULL)
  98            { cVal.siteID = atoi(value);}
  99     else if (os::strcasestr(key, "DURABILITY") != NULL)
 100            { cVal.isDurable = os::atobool(value); }
 101     else if (os::strcasestr(key, "DURABLE_MODE") != NULL)
 102            { cVal.durableMode = ::atoi(value); }
 103     else if (os::strcasestr(key, "CSQL_SQL_SERVER") != NULL)
 104            { cVal.isCsqlSqlServer = os::atobool(value); }
 105     else if (os::strcasestr(key, "PORT") != NULL)
 106            { cVal.port = atoi(value); }
 107     else if (os::strcasestr(key, "MAX_QUEUE_LOGS") != NULL)
 108            { cVal.maxQueueLogs = atol(value);  }
 109     else if (os::strcasestr(key, "MSG_KEY") != NULL)
 110            { cVal.msgKey = atoi(value);  }
 111     else if (os::strcasestr(key, "ASYNC_MSGMAX") != NULL)
 112            { cVal.asyncMsgMax = atoi(value);  }
 113     else if (os::strcasestr(key, "ID_SHM_KEY") != NULL)
 114            { cVal.shmKeyForId = atoi(value);  }
 115     else if (os::strcasestr(key, "NETWORK_RESPONSE_TIMEOUT") != NULL)
 116            { cVal.nwResponseTimeout = atoi(value);  }
 117     else if (os::strcasestr(key, "NETWORK_CONNECT_TIMEOUT") != NULL)
 118            { cVal.nwConnectTimeout = atoi(value);  }
 119     else if (os::strcasestr(key, "ENABLE_BIDIRECTIONAL_CACHE") != NULL)
 120            { cVal.isTwoWay = os::atobool(value);  }
 121     else if (os::strcasestr(key, "CACHE_RECEIVER_WAIT_SECS") != NULL)
 122            { cVal.cacheWaitSecs = atoi(value);  }
 123     else if (os::strcasestr(key, "STMT_CACHE_SIZE") != NULL)
 124            { cVal.stmtCacheSize = atoi(value);  }
 125     else if (os::strcasestr(key, "STMT_CACHE_NOPARAM") != NULL)
 126            { cVal.isCacheNoParam = os::atobool(value);  }
 127     else if (os::strcasestr(key, "MONITOR_SERVERS") != NULL)
 128            { cVal.isMonitor = os::atobool(value);  }
 129     else if (os::strcasestr(key, "CHECKPOINT_SECS") != NULL)
 130            { cVal.chkptSecs = ::atoi(value);  }
 131     else if (os::strcasestr(key, "CHECKPOINT_LOG_SIZE") != NULL)
 132            { cVal.chkptRedoLimit = ::atoi(value);  }
 133
 134
 135
 136     else  return 1;
 137     return 0;
 138 }
 139 int Config::validateValues()
 140 {
 141     if (cVal.pageSize < 8192 || cVal.pageSize > 1024 * 1024 * 10 )
 142     {
 143         printError(ErrBadArg,  "PAGE_SIZE should be >= 8192 and <= 10 MB");
 144         return 1;
 145     }
 146     if (cVal.pageSize  % 1024 !=0 )
 147     {
 148         printError(ErrBadArg,  "PAGE_SIZE should be multiples of 1024");
 149         return 1;
 150     }
 151     if (cVal.maxProcs < 10 || cVal.maxProcs > 8192)
 152     {
 153         printError(ErrBadArg,  "MAX_PROCS should be >= 10 and <= 8192");
 154         return 1;
 155     }
 156     if (cVal.maxSysSize < 1024 * 1024  || cVal.maxSysSize > 1024 *1024 *1024)
 157     {
 158         printError(ErrBadArg,  "MAX_SYS_DB_SIZE should be >= 1 MB and <= 1 GB");
 159         return 1;
 160     }
 161     if (cVal.maxSysSize % 8192 !=0 )
 162     {
 163         printError(ErrBadArg,  "MAX_SYS_DB_SIZE should be multiples of 8192");
 164         return 1;
 165     }
 166
 167     #ifdef x86_64
 168     if (cVal.maxDbSize < 1024 * 1024  || cVal.maxDbSize > ( 100*1024*1024*1024L))
 169     {
 170         printError(ErrBadArg,  "MAX_DB_SIZE should be >= 1 MB and <= 100 GB");
 171         return 1;
 172     }
 173     #else
 174     unsigned long maxVal = 2*1024*1024*1024L;
 175     if (cVal.maxDbSize < 1024 * 1024  || ((unsigned long)cVal.maxDbSize) > maxVal)
 176     {
 177         printError(ErrBadArg,  "MAX_DB_SIZE should be >= 1 MB and <= 2 GB");
 178         return 1;
 179     }
 180     #endif
 181     if (cVal.maxDbSize % 8192 !=0)
 182     {
 183         printError(ErrBadArg,  "MAX_DB_SIZE should be multiples of 8192");
 184         return 1;
 185     }
 186
 187     if (cVal.sysDbKey < 10 || cVal.sysDbKey > 8192)
 188     {
 189         printError(ErrBadArg,  "SYS_DB_KEY should be >= 10 and <= 8192");
 190         return 1;
 191     }
 192     if (cVal.userDbKey < 10 || cVal.userDbKey > 8192)
 193     {
 194         printError(ErrBadArg,  "USER_DB_KEY should be >= 10 and <= 8192");
 195         return 1;
 196     }
 197     if ( cVal.sysDbKey == cVal.userDbKey)
 198     {
 199         printError(ErrBadArg,  "USER_DB_KEY and SYS_DB_KEY have same value %d", cVal.userDbKey);
 200         return 1;
 201     }
 202     if (0 == strcmp(cVal.logFile,""))
 203     {
 204         //TODO::check whether file exists
 205         printError(ErrBadArg,  "LOG_FILE is set to NULL");
 206         return 1;
 207     }
 208     if (0 == strcmp(cVal.dbFile,""))
 209     {
 210         printError(ErrBadArg,  "LOG_FILE is set to NULL");
 211         return 1;
 212     }
 213 #if (!defined __sparcv9)
 214     if (cVal.mapAddr < 400000000 || cVal.mapAddr > 2000000000)
 215     {
 216         printError(ErrBadArg,  "MAP_ADDRESS should be >= 400000000 and <= 2000000000");
 217         return 1;
 218     }
 219 #endif
 220     if (cVal.mutexSecs < 0 || cVal.mutexSecs > 360)
 221     {
 222         printError(ErrBadArg,  "MUTEX_TIMEOUT_SECS should be >= 0 and <= 360");
 223         return 1;
 224     }
 225     if (cVal.mutexUSecs < 0 || cVal.mutexUSecs > 1000000)
 226     {
 227         printError(ErrBadArg,  "MUTEX_TIMEOUT_USECS should be >= 0 and <= 1000000");
 228         return 1;
 229     }
 230     if (cVal.mutexRetries < 0 || cVal.mutexRetries > 100)
 231     {
 232         printError(ErrBadArg,  "MUTEX_TIMEOUT_RETRY should be >= 0 and <= 100");
 233         return 1;
 234     }
 235     if (cVal.lockSecs < 0 || cVal.lockSecs > 360)
 236     {
 237         printError(ErrBadArg,  "LOCK_TIMEOUT_SECS should be >= 0 and <= 360");
 238         return 1;
 239     }
 240     if (cVal.lockUSecs < 0 || cVal.lockUSecs > 1000000)
 241     {
 242         printError(ErrBadArg,  "LOCK_TIMEOUT_USECS should be >= 0 and <= 1000000");
 243         return 1;
 244     }
 245     if (cVal.lockRetries < 0 || cVal.lockRetries > 100)
 246     {
 247         printError(ErrBadArg,  "LOCK_TIMEOUT_RETRY should be >= 0 and <= 100");
 248         return 1;
 249     }
 250     if (cVal.logLevel < 0 || cVal.logLevel > 3)
 251     {
 252         printError(ErrBadArg,  "LOG_LEVEL should be >= 0 and <= 3");
 253         return 1;
 254     }
 255     if (cVal.isCache) {
 256         if (0 == strcmp(cVal.dsn,""))
 257         {
 258             printError(ErrBadArg,  "DSN is set to NULL");
 259             return 1;
 260         }
 261     }
 262     if (cVal.isCache) {
 263         if (0 == strcmp(cVal.tableConfigFile,""))
 264         {
 265             //TODO::check whether file exists
 266             printError(ErrBadArg,  "TABLE_CONFIG_FILE is set to NULL");
 267             return 1;
 268         }
 269     }
 270     if (cVal.isCache && (cVal.nRowsToFetch < 1 || cVal.nRowsToFetch > 1000)) {
 271         printError(ErrBadArg, "Resultset cache is not in range [1 - 1000].");
 272         return 1;
 273     }
 274     if (cVal.nwResponseTimeout <0 || cVal.nwResponseTimeout > 60)
 275     {
 276         printError(ErrBadArg,  "NETWORK_RESPONSE_TIMEOUT should be 0 to 60");
 277         return 1;
 278     }
 279     if (cVal.nwConnectTimeout <0 || cVal.nwConnectTimeout > 60)
 280     {
 281         printError(ErrBadArg,  "NETWORK_CONNECT_TIMEOUT should be 0 to 60");
 282         return 1;
 283     }
 284     if (cVal.cacheWaitSecs <1)
 285     {
 286         printError(ErrBadArg,  "CACHE_RECEIVER_WAIT_SECS should be >1");
 287         return 1;
 288     }
 289     if (cVal.port <= 1024)
 290     {
 291         printError(ErrBadArg, "Invalid Port Number");
 292         return 1;
 293     }
 294     if (cVal.durableMode < 1  || cVal.durableMode >4)
 295     {
 296         if (!cVal.isDurable) {
 297             printError(ErrBadArg, "Durability is not enabled but mode is set");
 298         } else {
 299             printError(ErrBadArg, "Durable Mode should be 1 to 4");
 300         }
 301         return 1;
 302     }
 303     if (cVal.stmtCacheSize < 0 || cVal.stmtCacheSize > 1024)
 304     {
 305         printError(ErrBadArg, "STMT_CACHE_SIZE should be >=0 and <1024");
 306         return 1;
 307     }
 308     if (cVal.chkptSecs < 1 || cVal.chkptSecs > 1000000)
 309     {
 310         printError(ErrBadArg, "CHECKPOINT_SECS should be >=1 and <1000000");
 311         return 1;
 312     }
 313     if (cVal.chkptRedoLimit < 1024 * 1024 || cVal.stmtCacheSize > 1024 * 1024 * 1024)
 314     {
 315         printError(ErrBadArg, "CHECKPOINT_LOG_SIZE should be >=1MB and <1 GB");
 316         return 1;
 317     }
 318     return 0;
 319 }
 320
 321 int Config::readAllValues(char *fileName)
 322 {
 323     if (isLoaded) return 0;
 324     FILE *fp;
 325     if (fileName == NULL || 0 == strcmp(fileName, "")) fileName = DEFAULT_CONFIG_FILE;
 326     fp = fopen(fileName,"r");
 327     if( fp == NULL ) {
 328         printError(ErrSysInit, "Invalid path/filename in CSQL_CONFIG_FILE.");
 329         return 1;
 330     }
 331
 332     int hasData = 1;
 333     char buffer[1024];
 334     char key[1024];
 335     char value[1024];
 336     while (hasData)
 337     {
 338         memset(buffer, 0, 1024);
 339         //int ret = fscanf(fp,"%s\r",buffer);
 340         int ret = readLine(fp, buffer);
 341         if (ret == EOF) break;
 342         bool isComment= false;
 343         int posEqual =0;
 344         for (int i = 0; i <1024; i++)
 345         {
 346               if (buffer[i] == '=' ) posEqual=i;
 347               else if (buffer[i] == '#' ) { isComment = true; break; }
 348               else if (buffer[i] == '\n') { break; }
 349               else if (buffer[i] == '\0') { break; }
 350         }
 351       if (isComment) continue;
 352       if (!posEqual) continue;
 353       strncpy(key, buffer, posEqual);
 354       key[posEqual] = '\0';
 355       posEqual++;
 356       strcpy(value, &buffer[posEqual]);
 357       storeKeyVal(key, value);
 358     }
 359     fclose(fp);
 360     if (validateValues())
 361     {
 362         return 1;
 363     }
 364     cVal.noOfProcessors = os::getNoOfProcessors();
 365     isLoaded = true;
 366     return 0;
 367 }
 368 void Config::logConfig()
 369 {
 370     logFinest(Conf::logger, "Config: LOG_FILE %s", getLogFile());
 371     logFinest(Conf::logger, "Config: LOG_LEVEL %d", getLogLevel());
 372     logFinest(Conf::logger, "Config: DURABILITY %d", useDurability());
 373     logFinest(Conf::logger, "Config: MMAP %d", useMmap());
 374     logFinest(Conf::logger, "Config: DURABLE_MODE %d", getDurableMode());
 375     logFinest(Conf::logger, "Config: MUTEX_TIMEOUT_SECS %d", getMutexSecs());
 376     logFinest(Conf::logger, "Config: MUTEX_TIMEOUT_USECS %d", getMutexUSecs());
 377     logFinest(Conf::logger, "Config: MUTEX_TIMEOUT_RETRIES %d", getMutexRetries());
 378     logFinest(Conf::logger, "Config: LOCK_TIMEOUT_SECS %d", getLockSecs());
 379     logFinest(Conf::logger, "Config: LOCK_TIMEOUT_USECS %d", getLockUSecs());
 380     logFinest(Conf::logger, "Config: LOCK_TIMEOUT_RETRIES %d", getLockRetries());
 381 }
 382 void Config::print()
 383 {
 384     printf("ConfigValues\n");
 385     printf(" getPageSize %d\n", getPageSize());
 386     printf(" getMaxProcs %d\n", getMaxProcs());
 387     printf(" getMaxSysDbSize %ld\n", getMaxSysDbSize());
 388     printf(" getMaxDbSize %ld\n", getMaxDbSize());
 389     printf(" getSysDbKey %d\n", getSysDbKey());
 390     printf(" getUserDbKey %d\n", getUserDbKey());
 391     printf(" getLogFile %s\n", getLogFile());
 392     printf(" getLogLevel %d\n", getLogLevel());
 393     printf(" getDatabaseFile %s\n", getDbFile());
 394     printf(" getMapAddress %ld\n", getMapAddress());
 395     printf(" getMutexSecs %d\n", getMutexSecs());
 396     printf(" getMutexUSecs %d\n", getMutexUSecs());
 397     printf(" getMutexRetries %d\n", getMutexRetries());
 398     printf(" getLockSecs %d\n", getLockSecs());
 399     printf(" getLockUSecs %d\n", getLockUSecs());
 400     printf(" getLockRetries %d\n", getLockRetries());
 401     printf(" useCache %d\n", useCache());
 402     printf(" getDSN %s\n", getDSN());
 403     printf(" No of rows to Fetch from TDB %d\n", getNoOfRowsToFetchFromTDB());
 404     printf(" getDsConfigFile %s\n",getDsConfigFile());
 405     printf(" getTableConfigFile %s\n", getTableConfigFile());
 406     printf(" isTwoWayCache %d\n", useTwoWayCache());
 407     printf(" getCacheMode %d\n", getCacheMode());
 408     printf(" getCacheWaitSecs %d\n", getCacheWaitSecs());
 409     printf(" useCsqlSqlServer %d\n", useCsqlSqlServer());
 410     printf(" getPort %d\n", getPort());
 411     printf(" isDurable %d\n", useDurability());
 412     printf(" getSiteID %d\n", getSiteID());
 413     printf(" getMsgKey %d\n", getMsgKey());
 414     printf(" getShmIDKey %d\n", getShmIDKey());
 415 }