src/storage/SessionImpl.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<DatabaseManagerImpl.h>
  17 #include<DatabaseManager.h>
  18 #include<CatalogTables.h>
  19 #include<Database.h>
  20 #include<SessionImpl.h>
  21 #include<UserManager.h>
  22 #include<UserManagerImpl.h>
  23 #include<Transaction.h>
  24 #include<Debug.h>
  25 #include<Config.h>
  26 #include<Process.h>
  27
  28 #if (defined MMDB && defined EMBED)
  29 int SessionImpl::noOfThreads = 0;
  30 #endif
  31
  32 //Before calling this method, application is required to call readConfigValues
  33 DbRetVal SessionImpl::initSystemDatabase()
  34
  35 {
  36     long value=0;
  37
  38     DbRetVal rv = OK;
  39     rv = readConfigFile();
  40     if (rv != OK)
  41     {
  42        printError(ErrSysInit, "Configuration file read failed\n");
  43        return ErrSysInit;
  44     }
  45
  46    // Conf::config.print();
  47
  48     if (dbMgr == NULL) dbMgr = new DatabaseManagerImpl();
  49     rv = dbMgr->createDatabase(SYSTEMDB, Conf::config.getMaxSysDbSize());
  50     if (OK != rv) return rv;
  51
  52     dbMgr->setSysDb(dbMgr->db());
  53     dbMgr->setDb(NULL);
  54
  55     Database *db = dbMgr->sysDb();
  56
  57     rv = db->getXCheckpointMutex();
  58     if (OK != rv)
  59     {
  60         printError(ErrLockTimeOut, "Unable to get Database Mutex");
  61         return rv;
  62     }
  63
  64
  65     db->createAllCatalogTables();
  66
  67     //create the default dba user
  68     CatalogTableUSER cUser(db);
  69     rv = cUser.insert(I_USER, I_PASS);
  70     if (OK != rv)
  71     {
  72         db->releaseCheckpointMutex();
  73         return rv;
  74     }
  75
  76     rv = cUser.insert(DBAUSER, DBAPASS);
  77     if (OK != rv)
  78     {
  79         db->releaseCheckpointMutex();
  80         return rv;
  81     }
  82     void *ret = NULL;
  83     //Allocate space for the lock hash bucket
  84     ret = db->allocLockHashBuckets();
  85     if (NULL == ret)
  86     {
  87         db->releaseCheckpointMutex();
  88         printError(ErrSysInit, "Allocation of Lock buckets failed");
  89         return ErrSysInit;
  90     }
  91     Bucket* buckets = dbMgr->sysDb()->getLockHashBuckets();
  92     Bucket* bucket;
  93     char mutName[IDENTIFIER_LENGTH];
  94     for (int i =0; i< LOCK_BUCKET_SIZE; i++)
  95     {
  96        bucket = &(buckets[i]);
  97        sprintf(mutName, "LOCKBKT:%d", i);
  98        bucket->mutex_.init(mutName);
  99     }
 100
 101     db->releaseCheckpointMutex();
 102 #if !(defined MMDB && defined EMBED)
 103     printf("Sys_DB  [Size=%4.4ldMB] \nUser_DB [Size=%4.4ldMB]\n", Conf::config.getMaxSysDbSize()/1048576, Conf::config.getMaxDbSize()/1048576);
 104 #endif
 105     //create user database
 106     rv = dbMgr->createDatabase("userdb", Conf::config.getMaxDbSize());
 107     if (OK != rv) return rv;
 108     return OK;
 109 }
 110
 111 DbRetVal SessionImpl::destroySystemDatabase()
 112 {
 113     DbRetVal rv = OK;
 114     rv = dbMgr->deleteDatabase(SYSTEMDB);
 115     if (OK != rv) return rv;
 116     rv = dbMgr->deleteDatabase("userdb");
 117     if (OK != rv) return rv;
 118     delete dbMgr;
 119     dbMgr = NULL;
 120     return OK;
 121 }
 122
 123 DbRetVal SessionImpl::open(const char *username, const char *password)
 124 {
 125 #if (defined MMDB) && (defined EMBED)
 126     openEmbeddedConnection(username, password);
 127 # else
 128     DbRetVal rv = OK;
 129     rv = readConfigFile();
 130     if (rv != OK)
 131     {
 132        printError(ErrSysFatal, "Configuration file read failed\n");
 133        return ErrSysFatal;
 134     }
 135
 136     if ( NULL == dbMgr)
 137     {
 138         dbMgr = new DatabaseManagerImpl();
 139     }
 140     int ret = ProcessManager::mutex.tryLock(10, 100);
 141     //If you are not getting lock ret !=0, it means somebody else is there.
 142     if (ret != 0)
 143     {
 144         printError(ErrSysInternal, "Another thread calling open:Wait and then Retry\n");
 145         return ErrSysInternal;
 146     }
 147     rv = dbMgr->openSystemDatabase();
 148     if (OK != rv)
 149     {
 150         printError(rv,"Unable to open the system database");
 151         ProcessManager::mutex.releaseLock(-1, false);
 152         return rv;
 153     }
 154
 155     rv = authenticate(username, password);
 156     if (OK != rv)
 157     {
 158         dbMgr->closeSystemDatabase();
 159         delete dbMgr; dbMgr = NULL;
 160         ProcessManager::mutex.releaseLock(-1, false);
 161         return rv;
 162     }
 163
 164     dbMgr->createTransactionManager();
 165     dbMgr->createLockManager();
 166     rv = dbMgr->registerThread();
 167     if (OK != rv)
 168     {
 169         printError(rv,"Unable to register to csql server");
 170         dbMgr->closeSystemDatabase();
 171         ProcessManager::mutex.releaseLock(-1, false);
 172         delete dbMgr; dbMgr = NULL;
 173         return rv;
 174     }
 175     rv = dbMgr->openDatabase("userdb");
 176     if (OK != rv) {
 177         dbMgr->closeSystemDatabase();
 178         ProcessManager::mutex.releaseLock(-1, false);
 179         delete dbMgr; dbMgr = NULL;
 180         return rv;
 181     }
 182     ProcessManager::mutex.releaseLock(-1, false);
 183     ((DatabaseManagerImpl*)dbMgr)->setProcSlot();
 184     //ProcessManager::systemDatabase = dbMgr->sysDb();
 185     isXTaken = false;
 186     return OK;
 187 #endif
 188 }
 189 DbRetVal SessionImpl::authenticate(const char *username, const char *password)
 190 {
 191     CatalogTableUSER cUser(dbMgr->sysDb());
 192     cUser.authenticate(username, password, isAuthenticated, isDba);
 193     strcpy(userName, username);
 194     if (!isAuthenticated)
 195     {
 196         printError(ErrNoPrivilege,"User Authentication failed");
 197         return ErrNoPrivilege;
 198     }
 199     return OK;
 200 }
 201 DbRetVal SessionImpl::getExclusiveLock()
 202 {
 203    DbRetVal rv = dbMgr->sysDb()->getProcessTableMutex(true);
 204    if (OK != rv) {
 205       printError(ErrLockTimeOut, "Unable to acquire proc table mutex");
 206       return rv;
 207    }
 208    if (dbMgr->isAnyOneRegistered()) {
 209       printError(ErrLockTimeOut, "Unable to acquire exclusive lock. somebody is connected");
 210       dbMgr->sysDb()->releaseProcessTableMutex(true);
 211       return ErrLockTimeOut;
 212    }
 213    isXTaken = true;
 214    return rv;
 215 }
 216 DbRetVal SessionImpl::close()
 217 {
 218 # if (defined MMDB) && (defined EMBED)
 219     closeEmbeddedConnection();
 220 # else
 221     DbRetVal rv = OK;
 222     if (isXTaken && dbMgr ) dbMgr->sysDb()->releaseProcessTableMutex(true);
 223     if (dbMgr)
 224     {
 225         int ret = ProcessManager::mutex.tryLock(10,100);
 226         //If you are not getting lock ret !=0, it means somebody else is there.
 227         if (ret != 0)
 228         {
 229            printError(ErrSysInternal, "Another thread calling open:Wait and then Retry\n");
 230            return ErrSysInternal;
 231         }
 232
 233         rv = dbMgr->closeDatabase();
 234         if (rv != OK) {
 235            ProcessManager::mutex.releaseLock(-1, false);
 236            return ErrBadCall;
 237         }
 238         rv = dbMgr->deregisterThread();
 239         if (rv != OK) {
 240            ProcessManager::mutex.releaseLock(-1, false);
 241            return ErrBadCall;
 242         }
 243         rv = dbMgr->closeSystemDatabase();
 244         if (rv != OK) {
 245              ProcessManager::mutex.releaseLock(-1, false);
 246              return ErrBadCall;
 247         }
 248         ProcessManager::mutex.releaseLock(-1, false);
 249         delete dbMgr;
 250         dbMgr = NULL;
 251     }
 252     if (uMgr)
 253     {
 254         delete uMgr;
 255         uMgr = NULL;
 256     }
 257     isXTaken = false;
 258     return OK;
 259 #endif
 260 }
 261
 262 DatabaseManager* SessionImpl::getDatabaseManager()
 263 {
 264     return dbMgr;
 265 }
 266
 267 UserManager* SessionImpl::getUserManager()
 268 {
 269     if (!isAuthenticated)
 270     {
 271         printError(ErrNoPrivilege, "Not Authenticated: Returning NULL");
 272         return NULL;
 273     }
 274     if (uMgr != NULL) return uMgr;
 275     UserManagerImpl *userMgr =  new UserManagerImpl();
 276     if(0 == strcmp(userName, DBAUSER))
 277         userMgr->setDba(true);
 278     else
 279         userMgr->setDba(false);
 280
 281     userMgr->setSysDb(dbMgr->sysDb());
 282
 283     userMgr->setUserName(userName);
 284     uMgr = userMgr;
 285     return userMgr;
 286 }
 287
 288 DbRetVal SessionImpl::startTransaction(IsolationLevel level)
 289 {
 290     if (NULL == dbMgr || NULL == dbMgr->txnMgr())
 291     {
 292         printError(ErrSysFatal, "Database Manager or Txn Manager object is NULL");
 293         return ErrSysFatal;
 294     }
 295     DbRetVal rv = OK;
 296
 297     rv = dbMgr->txnMgr()->startTransaction(dbMgr->lockMgr(), level);
 298     return rv;
 299 }
 300
 301
 302 DbRetVal SessionImpl::commit()
 303 {
 304     DbRetVal rv = OK;
 305     if (NULL == dbMgr || NULL == dbMgr->txnMgr())
 306     {
 307         printError(ErrSysFatal, "Database Manager or Txn Manager object is NULL");
 308         return ErrSysFatal;
 309     }
 310     rv = dbMgr->txnMgr()->commit(dbMgr->lockMgr());
 311     if (OK != rv)
 312     {
 313         printError(rv,"Transaction commit failed\n");
 314         return rv;
 315     }
 316     return OK;
 317 }
 318
 319
 320 DbRetVal SessionImpl::rollback()
 321 {
 322     DbRetVal rv = OK;
 323     if (NULL == dbMgr || NULL == dbMgr->txnMgr())
 324     {
 325         printError(ErrSysFatal, "Database Manager or Txn Manager object is NULL");
 326         return ErrSysFatal;
 327     }
 328     rv = dbMgr->txnMgr()->rollback(dbMgr->lockMgr());
 329     if (OK != rv)
 330     {
 331         printError(rv, "Transaction rollback failed\n");
 332         return rv;
 333     }
 334     return OK;
 335 }
 336
 337 DbRetVal SessionImpl::readConfigFile()
 338 {
 339     // Check if env variable is set or not
 340     char *confFilename = os::getenv("CSQL_CONFIG_FILE");
 341     if (confFilename == NULL)
 342     {
 343         if (os::fileExists(DEFAULT_CONFIG_FILE)) {
 344            confFilename = DEFAULT_CONFIG_FILE;
 345         }
 346         else  {
 347            printError(ErrSysInit, "CSQL_CONFIG_FILE environment variable "
 348                                   "should be set.");
 349            return ErrSysInit;
 350         }
 351     }
 352
 353     int  rv = Conf::config.readAllValues(confFilename);
 354     if (rv != 0) return ErrSysInit;
 355     return OK;
 356 }
 357 Database* SessionImpl::getSystemDatabase()
 358 {
 359     return dbMgr->sysDb();
 360 }
 361
 362 #if (defined MMDB && defined EMBED)
 363 DbRetVal SessionImpl::openEmbeddedConnection(const char *username, const char *password)
 364 {
 365     DbRetVal rv = OK;
 366     rv = readConfigFile();
 367     if (rv != OK)
 368     {
 369        printError(ErrSysFatal, "Configuration file read failed\n");
 370        return ErrSysFatal;
 371     }
 372
 373     if ( NULL == dbMgr)
 374     {
 375         dbMgr = new DatabaseManagerImpl();
 376     }
 377     int ret = ProcessManager::mutex.tryLock(10, 100);
 378     //If you are not getting lock ret !=0, it means somebody else is there.
 379     if (ret != 0)
 380     {
 381         printError(ErrSysInternal, "Another thread calling open:Wait and then Retry\n");
 382         return ErrSysInternal;
 383     }
 384
 385     if (!noOfThreads) {
 386         ret = initSystemDatabase();
 387         if (0  != ret) {
 388             printError(ErrSysInternal, "Unable to initialize the Database");
 389             ProcessManager::mutex.releaseLock(-1, false);
 390             return ErrSysInternal;
 391         }
 392         ProcessManager::systemDatabase = dbMgr->sysDb();
 393     } else {
 394         rv = dbMgr->openSystemDatabase();
 395         if (OK != rv)
 396         {
 397             printError(rv,"Unable to open the system database");
 398             ProcessManager::mutex.releaseLock(-1, false);
 399             return rv;
 400         }
 401     }
 402
 403     rv = authenticate(username, password);
 404     if (OK != rv)
 405     {
 406         delete dbMgr; dbMgr = NULL;
 407         ProcessManager::mutex.releaseLock(-1, false);
 408         return rv;
 409     }
 410
 411     dbMgr->createTransactionManager();
 412     dbMgr->createLockManager();
 413     if (noOfThreads) {
 414         rv = dbMgr->openDatabase("userdb");
 415         if (OK != rv) {
 416             dbMgr->closeSystemDatabase();
 417             ProcessManager::mutex.releaseLock(-1, false);
 418             delete dbMgr; dbMgr = NULL;
 419             return rv;
 420         }
 421     }
 422
 423     rv = dbMgr->registerThread();
 424     if (OK != rv)
 425     {
 426         printError(rv,"Unable to register to csql server");
 427         ProcessManager::mutex.releaseLock(-1, false);
 428         delete dbMgr; dbMgr = NULL;
 429         return rv;
 430     }
 431
 432     ProcessManager::mutex.releaseLock(-1, false);
 433     noOfThreads++;
 434     return OK;
 435 }
 436
 437 DbRetVal SessionImpl::closeEmbeddedConnection()
 438 {
 439     DbRetVal rv = OK;
 440     if (dbMgr)
 441     {
 442         int ret = ProcessManager::mutex.tryLock(10,100);
 443         //If you are not getting lock ret !=0, it means somebody else is there.
 444         if (ret != 0)
 445         {
 446            printError(ErrSysInternal, "Another thread calling open:Wait and then Retry\n");
 447            return ErrSysInternal;
 448         }
 449
 450         rv = dbMgr->deregisterThread();
 451         if (rv != OK) {
 452            ProcessManager::mutex.releaseLock(-1, false);
 453            return ErrBadCall;
 454         }
 455         ProcessManager::mutex.releaseLock(-1, false);
 456     }
 457     if (uMgr)
 458     {
 459         delete uMgr;
 460         uMgr = NULL;
 461     }
 462     if(noOfThreads == 1) {
 463         destroySystemDatabase();
 464         Conf::logger.stopLogger();
 465     }
 466     noOfThreads--;
 467     return OK;
 468 }
 469 #endif