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