src/gateway/SqlGwConnection.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Prabakaran Thirumalai   *
   3  *   praba_tuty@yahoo.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  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #include <os.h>
  21 #include <SqlGwConnection.h>
  22 #include<SqlOdbcConnection.h>
  23 #include <CSql.h>
  24 #include <Network.h>
  25
  26 List SqlGwConnection::cacheList;
  27
  28 SqlGwConnection::~SqlGwConnection()
  29 {
  30     struct MultiDSN *node=NULL, *prev=NULL;
  31     node = multi_adapter_head;
  32     while(node!=NULL){
  33         if(node->isConnected) node->adapter->disconnect();
  34         delete node->adapter;
  35         prev=node;
  36         node=node->next;
  37         delete prev;
  38    }
  39  /*   if (isAdapterConnected) {
  40         adapter->disconnect();
  41         isAdapterConnected = false;
  42     } */
  43     ListIterator it = cacheList.getIterator();
  44     while(it.hasElement()) delete (CachedTable *) it.nextElement();
  45     cacheList.reset();
  46    // if (adapter) { delete adapter; adapter = NULL; }
  47 }
  48
  49 //createAdapters
  50 void SqlGwConnection::createAdapters(SqlGwConnection *gwconn)
  51 {
  52     FILE *fp = NULL;
  53     fp = fopen(Conf::config.getDsConfigFile(),"r");
  54     if(fp==NULL){
  55         printError(ErrSysInit,"csqlds.conf file does not exist");
  56         exit(1);
  57     }
  58
  59     char dsnname[IDENTIFIER_LENGTH];dsnname[0]='\0';
  60     char tdb[IDENTIFIER_LENGTH];
  61     char username[IDENTIFIER_LENGTH];
  62     char password[IDENTIFIER_LENGTH];
  63
  64     while(!feof(fp)){
  65         AbsSqlConnection *adapterCon = new SqlOdbcConnection();
  66         fscanf(fp,"%s %s %s %s\n",dsnname,username,password,tdb);
  67         if(strcmp(dsnname,"") == 0){
  68             printf("Add entry to csqlds.conf file\n");
  69             exit(1);
  70         }
  71         gwconn->setAdapter(adapterCon,dsnname);
  72     }
  73     fclose(fp);
  74 }
  75
  76 //Putting different "Adapter" object into List
  77 void SqlGwConnection::setAdapter(AbsSqlConnection *conn, char *dsName)
  78 {
  79     struct MultiDSN *new_node=new struct MultiDSN;
  80     struct MultiDSN *link_node=NULL;
  81     strcpy(new_node->dsn,dsName);
  82     new_node->adapter=conn;
  83     new_node->next=NULL;
  84     new_node->toCommit=false;
  85     new_node->isConnected=false;
  86     noOfCon++;
  87     if(multi_adapter_head == NULL){ multi_adapter_head=new_node; return;}
  88     link_node=multi_adapter_head;
  89     while(link_node != NULL) {
  90         if(link_node->next == NULL) {
  91             link_node->next = new_node;
  92             return;
  93         }
  94         link_node = link_node->next;
  95     }
  96 }
  97
  98 //getAdapter
  99 AbsSqlConnection* SqlGwConnection::getAdapterConnection(char *dsName)
 100 {
 101    struct MultiDSN *node;
 102    node=multi_adapter_head;
 103    while(node!=NULL){
 104        if(strcmp(node->dsn,dsName)==0)
 105        return node->adapter;
 106         node=node->next;
 107    }
 108    return NULL;
 109 }
 110
 111 DbRetVal SqlGwConnection::connect (char *user, char * pass)
 112 {
 113    // SqlOdbcConnection *dsnAda=(SqlOdbcConnection*) adapter;
 114     struct MultiDSN *node=multi_adapter_head;
 115     isCSqlConnected = false;
 116     isAdapterConnected = false;
 117     strcpy(username, user);
 118     strcpy(password, pass);
 119     DbRetVal rv = OK;
 120     if (innerConn) rv = innerConn->connect(user,pass);
 121     if (rv == OK) isCSqlConnected = true;
 122     if (rv == ErrNoPrivilege ) return rv;
 123     // Get the appropriate "Adapter" object based on DSN from the MultiDsn List
 124     while(node !=NULL ){
 125        adapter=getAdapterConnection(node->dsn);
 126        SqlOdbcConnection *dsnAda=(SqlOdbcConnection*) adapter;
 127        dsnAda->setDsn(node->dsn);
 128        //Below function will connect to TDB
 129        if(adapter) rv = adapter->connect(user,pass);
 130        if(OK == rv) node->isConnected = true;
 131        node=node->next;
 132     }
 133     //if (adapter) rv = adapter->connect(user,pass);
 134     if (0 == cacheList.size()) rv = populateCachedTableList();
 135     if (rv == OK) isAdapterConnected = true;
 136     if (!isAdapterConnected && !isCSqlConnected) return ErrNoConnection;
 137     return OK;
 138 }
 139
 140 DbRetVal SqlGwConnection::disconnect()
 141 {
 142     DbRetVal rv = OK;
 143     if (innerConn && isCSqlConnected) rv =innerConn->disconnect();
 144     if (rv != OK) return rv;
 145     struct MultiDSN *node=NULL ;
 146     node = multi_adapter_head;
 147     if (isAdapterConnected){
 148         while(node!=NULL){
 149             if(node->isConnected) node->adapter->disconnect();
 150             node=node->next;
 151         }
 152     }
 153    // if (adapter && isAdapterConnected) rv = adapter->disconnect();
 154     isCSqlConnected = false;
 155     isAdapterConnected = false;
 156     return rv;
 157 }
 158 DbRetVal SqlGwConnection::beginTrans(IsolationLevel isoLevel, TransSyncMode smode)
 159 {
 160     DbRetVal rv = OK;
 161     if (!isAdapterConnected && !isCSqlConnected) return ErrNoConnection;
 162     if (innerConn && isCSqlConnected) rv =  innerConn->beginTrans(isoLevel, smode);
 163     if (rv != OK) return rv;
 164     struct MultiDSN *node=NULL;
 165     node = multi_adapter_head;
 166     if (isAdapterConnected)
 167     {
 168          while(node!=NULL){
 169             if(node->isConnected) node->adapter->beginTrans(isoLevel);
 170             node=node->next;
 171         }
 172     }
 173     //mode = smode;
 174     txnHdlr = CSqlHandler;
 175     return rv;
 176 }
 177 DbRetVal SqlGwConnection::commit()
 178 {
 179     struct MultiDSN *node = multi_adapter_head;
 180     DbRetVal rv = OK;
 181
 182     if (innerConn && isCSqlConnected)
 183         //(txnHdlr == CSqlHandler || txnHdlr == CSqlAndAdapterHandler))
 184         rv = innerConn->commit();
 185     if (rv != OK) return rv;
 186     //Commit happen in every TDB, those are present in "csqlds.conf" file.
 187     while(node != NULL){
 188        // if (adapter &&  (txnHdlr == AdapterHandler || txnHdlr == CSqlAndAdapterHandler))
 189        if (txnHdlr == AdapterHandler || txnHdlr == CSqlAndAdapterHandler){
 190            if(node->toCommit){
 191                rv = (node->adapter)->commit();
 192                node->toCommit=false;
 193            }
 194
 195        }
 196        node=node->next;
 197     }
 198     if (!isAdapterConnected && !isCSqlConnected) return ErrNoConnection;
 199     return rv;
 200 }
 201 DbRetVal SqlGwConnection::rollback()
 202 {
 203     DbRetVal rv = OK;
 204     if (innerConn && isCSqlConnected) //(txnHdlr == CSqlHandler || txnHdlr == CSqlAndAdapterHandler))
 205         rv =  innerConn->rollback();
 206     if (rv != OK) return rv;
 207     struct MultiDSN *node=NULL;
 208     node = multi_adapter_head;
 209     if (isAdapterConnected && (txnHdlr == AdapterHandler || txnHdlr == CSqlAndAdapterHandler))
 210     {
 211          while(node!=NULL){
 212             if(node->isConnected) node->adapter->rollback();
 213             node=node->next;
 214         }
 215     }
 216 /*
 217     if (adapter && isAdapterConnected &&
 218         (txnHdlr == AdapterHandler || txnHdlr == CSqlAndAdapterHandler))
 219         rv = adapter->rollback();
 220 */
 221     if (!isAdapterConnected && !isCSqlConnected) return ErrNoConnection;
 222     return rv;
 223 }
 224 DbRetVal SqlGwConnection::connectCSqlIfNotConnected()
 225 {
 226     if (!isCSqlConnected) {
 227         DbRetVal rv = innerConn->connect(username, password);
 228         if (rv != OK) return rv;
 229         isCSqlConnected = true;
 230     }
 231     return OK;
 232 }
 233 DbRetVal SqlGwConnection::connectAdapterIfNotConnected()
 234 {
 235     if (!isAdapterConnected) {
 236         DbRetVal rv = adapter->connect(username, password);
 237         if (rv != OK) return rv;
 238         isAdapterConnected = true;
 239     }
 240     return OK;
 241 }
 242
 243 bool SqlGwConnection::isTableCached(char *tblName)
 244 {
 245     if (NULL == tblName)
 246     {
 247         printError(ErrBadArg, "tblName passed is NULL\n");
 248         return ErrBadArg;
 249     }
 250     ListIterator iter = cacheList.getIterator();
 251     CachedTable *node;
 252     while (iter.hasElement()) {
 253         node = (CachedTable*)iter.nextElement();
 254         if (strcmp(node->tableName, tblName) == 0)
 255         {
 256            return true;
 257         }
 258     }
 259     return false;
 260 }
 261 DbRetVal SqlGwConnection::populateCachedTableList()
 262 {
 263     FILE *fp = NULL;
 264     fp = fopen(Conf::config.getTableConfigFile(),"r");
 265     if( fp == NULL ) {
 266         printError(ErrSysInit, "cache.table file does not exist");
 267         return ErrSysInit;
 268     }
 269     char tablename[IDENTIFIER_LENGTH];
 270     char fieldname[IDENTIFIER_LENGTH];
 271     char condition[IDENTIFIER_LENGTH];
 272     char field[IDENTIFIER_LENGTH];
 273     char dsnName[IDENTIFIER_LENGTH];
 274
 275     int cmode;
 276     CachedTable *node;
 277     while(!feof(fp))
 278     {
 279         fscanf(fp, "%d %s %s %s %s %s \n", &cmode, tablename,fieldname,condition,field,dsnName);
 280         node = new CachedTable();
 281         strcpy(node->tableName, tablename);
 282         cacheList.append(node);
 283     }
 284     fclose(fp);
 285     return OK;
 286 }
 287