mirror of https://github.com/sipwise/kamailio.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
513 lines
13 KiB
513 lines
13 KiB
/*
|
|
* $Id$
|
|
*
|
|
* DB CLuster core functions
|
|
*
|
|
* Copyright (C) 2012 Daniel-Constantin Mierla (asipto.com)
|
|
*
|
|
* This file is part of Kamailio, a free SIP server.
|
|
*
|
|
* Kamailio is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version
|
|
*
|
|
* Kamailio is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
/*! \file
|
|
* \brief DB_CLUSTER :: Core
|
|
* \ingroup db_cluster
|
|
* Module: \ref db_cluster
|
|
*/
|
|
|
|
#include "../../dprint.h"
|
|
#include "../../hashes.h"
|
|
#include "../../trim.h"
|
|
#include "../../globals.h"
|
|
#include "../../lib/srdb1/db.h"
|
|
#include "../../timer.h"
|
|
|
|
#include "dbcl_data.h"
|
|
#include "dbcl_api.h"
|
|
|
|
extern int dbcl_max_query_length;
|
|
|
|
#define DBCL_READ(qfunc, command) \
|
|
do {\
|
|
int ret;\
|
|
int i;\
|
|
int j;\
|
|
int k;\
|
|
unsigned int sec = 0;\
|
|
db1_con_t *dbh=NULL;\
|
|
dbcl_cls_t *cls=NULL;\
|
|
cls = (dbcl_cls_t*)_h->tail;\
|
|
ret = -1;\
|
|
for(i=DBCL_PRIO_SIZE-1; i>0; i--)\
|
|
{\
|
|
if(cls->rlist[i].clen<=0) continue; \
|
|
switch(cls->rlist[i].mode) {\
|
|
case 's':\
|
|
case 'S':\
|
|
for(j=0; j<cls->rlist[i].clen; j++)\
|
|
{\
|
|
if(dbcl_valid_con(cls->rlist[i].clist[j])==0)\
|
|
{\
|
|
LM_DBG("serial operation - cluster [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks();\
|
|
dbh = cls->rlist[i].clist[j]->dbh;\
|
|
if(cls->rlist[i].clist[j]->dbf.qfunc==NULL) {\
|
|
LM_ERR("unsupported command by db connector\n");\
|
|
return -1;\
|
|
}\
|
|
ret = cls->rlist[i].clist[j]->dbf.command;\
|
|
if (ret==0) {\
|
|
cls->usedcon = cls->rlist[i].clist[j];\
|
|
return 0;\
|
|
} else {\
|
|
LM_DBG("serial operation - failre on cluster"\
|
|
" [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks() - sec;\
|
|
if(sec >= dbcl_max_query_length){\
|
|
dbcl_inactive_con(cls->rlist[i].clist[j]);\
|
|
}\
|
|
}\
|
|
}\
|
|
}\
|
|
break;\
|
|
case 'r':\
|
|
case 'R':\
|
|
for(k=0; k<cls->rlist[i].clen; k++)\
|
|
{\
|
|
j = (process_no + k + cls->rlist[i].crt) % cls->rlist[i].clen;\
|
|
if(dbcl_valid_con(cls->rlist[i].clist[j])==0)\
|
|
{\
|
|
LM_DBG("round robin operation - cluster [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks();\
|
|
dbh = cls->rlist[i].clist[j]->dbh;\
|
|
if(cls->rlist[i].clist[j]->dbf.qfunc==NULL) {\
|
|
LM_ERR("unsupported command by db connector\n");\
|
|
return -1;\
|
|
}\
|
|
ret = cls->rlist[i].clist[j]->dbf.command;\
|
|
if (ret==0)\
|
|
{\
|
|
cls->usedcon = cls->rlist[i].clist[j];\
|
|
cls->rlist[i].crt = (j+1) % cls->rlist[i].clen;\
|
|
return 0;\
|
|
} else {\
|
|
LM_DBG("round robin operation - failre on cluster"\
|
|
" [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks() - sec;\
|
|
if(sec >= dbcl_max_query_length){\
|
|
dbcl_inactive_con(cls->rlist[i].clist[j]);\
|
|
}\
|
|
}\
|
|
}\
|
|
}\
|
|
break;\
|
|
default:\
|
|
LM_ERR("invalid mode %c (%d)\n", cls->rlist[i].mode,\
|
|
cls->rlist[i].mode);\
|
|
return -1;\
|
|
}\
|
|
}\
|
|
LM_DBG("no successful read on cluster [%.*s]\n",\
|
|
cls->name.len, cls->name.s);\
|
|
return ret;\
|
|
} while(0)
|
|
|
|
#define DBCL_WRITE(qfunc, command) \
|
|
do {\
|
|
int ret;\
|
|
int rc;\
|
|
int rok;\
|
|
int i;\
|
|
int j;\
|
|
int k;\
|
|
unsigned int sec = 0;\
|
|
db1_con_t *dbh=NULL;\
|
|
dbcl_cls_t *cls=NULL;\
|
|
cls = (dbcl_cls_t*)_h->tail;\
|
|
ret = -1;\
|
|
rok = 0;\
|
|
rc = 0;\
|
|
for(i=DBCL_PRIO_SIZE-1; i>0; i--)\
|
|
{\
|
|
if(cls->wlist[i].clen<=0) continue; \
|
|
switch(cls->wlist[i].mode) {\
|
|
case 's':\
|
|
case 'S':\
|
|
for(j=0; j<cls->wlist[i].clen; j++)\
|
|
{\
|
|
if(dbcl_valid_con(cls->wlist[i].clist[j])==0)\
|
|
{\
|
|
LM_DBG("serial operation - cluster [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks();\
|
|
dbh = cls->wlist[i].clist[j]->dbh;\
|
|
if(cls->wlist[i].clist[j]->dbf.qfunc==NULL) {\
|
|
LM_ERR("unsupported command by db connector\n");\
|
|
return -1;\
|
|
}\
|
|
ret = cls->wlist[i].clist[j]->dbf.command;\
|
|
if (ret==0) {\
|
|
cls->usedcon = cls->wlist[i].clist[j];\
|
|
return 0;\
|
|
} else {\
|
|
LM_DBG("serial operation - failure on cluster"\
|
|
" [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks() - sec;\
|
|
if(sec >= dbcl_max_query_length){\
|
|
dbcl_inactive_con(cls->wlist[i].clist[j]);\
|
|
}\
|
|
}\
|
|
}\
|
|
}\
|
|
break;\
|
|
case 'r':\
|
|
case 'R':\
|
|
for(k=0; k<cls->wlist[i].clen; k++)\
|
|
{\
|
|
j = (process_no + k + cls->wlist[i].crt) % cls->wlist[i].clen;\
|
|
if(dbcl_valid_con(cls->wlist[i].clist[j])==0)\
|
|
{\
|
|
LM_DBG("round robin operation - cluster [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks();\
|
|
dbh = cls->wlist[i].clist[j]->dbh;\
|
|
if(cls->wlist[i].clist[j]->dbf.qfunc==NULL) {\
|
|
LM_ERR("unsupported command by db connector\n");\
|
|
return -1;\
|
|
}\
|
|
ret = cls->wlist[i].clist[j]->dbf.command;\
|
|
if (ret==0)\
|
|
{\
|
|
cls->usedcon = cls->wlist[i].clist[j];\
|
|
cls->wlist[i].crt = (j+1) % cls->wlist[i].clen;\
|
|
return 0;\
|
|
} else {\
|
|
LM_DBG("round robin operation - failure on cluster"\
|
|
" [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks() - sec;\
|
|
if(sec >= dbcl_max_query_length){\
|
|
dbcl_inactive_con(cls->wlist[i].clist[j]);\
|
|
}\
|
|
}\
|
|
}\
|
|
}\
|
|
break;\
|
|
case 'p':\
|
|
case 'P':\
|
|
for(j=0; j<cls->wlist[i].clen; j++)\
|
|
{\
|
|
if(dbcl_valid_con(cls->wlist[i].clist[j])==0)\
|
|
{\
|
|
LM_DBG("parallel operation - cluster [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks();\
|
|
dbh = cls->wlist[i].clist[j]->dbh;\
|
|
if(cls->wlist[i].clist[j]->dbf.qfunc==NULL) {\
|
|
LM_ERR("unsupported command by db connector\n");\
|
|
return -1;\
|
|
}\
|
|
rc = cls->wlist[i].clist[j]->dbf.command;\
|
|
if(rc==0) {\
|
|
cls->usedcon = cls->wlist[i].clist[j];\
|
|
rok = 1;\
|
|
} else {\
|
|
LM_DBG("parallel operation - failure on cluster"\
|
|
" [%.*s] (%d/%d)\n",\
|
|
cls->name.len, cls->name.s, i, j);\
|
|
sec = get_ticks() - sec;\
|
|
if(sec >= dbcl_max_query_length){\
|
|
dbcl_inactive_con(cls->wlist[i].clist[j]);\
|
|
}\
|
|
}\
|
|
ret |= rc;\
|
|
}\
|
|
}\
|
|
if (rok==1 && cls->wlist[i].clen>0)\
|
|
return 0;\
|
|
break;\
|
|
default:\
|
|
LM_ERR("invalid mode %c (%d)\n", cls->rlist[i].mode,\
|
|
cls->rlist[i].mode);\
|
|
return -1;\
|
|
}\
|
|
}\
|
|
LM_DBG("no successful write on cluster [%.*s]\n",\
|
|
cls->name.len, cls->name.s);\
|
|
return ret;\
|
|
} while(0)
|
|
|
|
|
|
|
|
/*! \brief
|
|
* Initialize database connection
|
|
*/
|
|
db1_con_t* db_cluster_init(const str* _dburl)
|
|
{
|
|
db1_con_t *h=NULL;
|
|
dbcl_cls_t *cls=NULL;
|
|
str name;
|
|
|
|
LM_DBG("initializing with cluster [%.*s]\n", _dburl->len, _dburl->s);
|
|
if(_dburl->len<10 || strncmp(_dburl->s, "cluster://", 10)!=0)
|
|
{
|
|
LM_ERR("invlaid url for cluster module [%.*s]\n",
|
|
_dburl->len, _dburl->s);
|
|
return NULL;
|
|
}
|
|
name.s = _dburl->s + 10;
|
|
name.len = _dburl->len - 10;
|
|
trim(&name);
|
|
cls = dbcl_get_cluster(&name);
|
|
if(cls==NULL)
|
|
{
|
|
LM_ERR("cluster not found [%.*s]\n",
|
|
_dburl->len, _dburl->s);
|
|
return NULL;
|
|
}
|
|
if(dbcl_init_dbf(cls)<0)
|
|
{
|
|
LM_ERR("cluster [%.*s] - unable to bind to DB engines\n",
|
|
_dburl->len, _dburl->s);
|
|
return NULL;
|
|
}
|
|
dbcl_init_connections(cls);
|
|
cls->ref++;
|
|
h = (db1_con_t*)pkg_malloc(sizeof(db1_con_t));
|
|
if (h==NULL) {
|
|
LM_ERR("out of pkg\n");
|
|
return NULL;
|
|
}
|
|
memset(h, 0, sizeof(db1_con_t));
|
|
h->tail = (unsigned long)cls;
|
|
return h;
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Close a database connection
|
|
*/
|
|
void db_cluster_close(db1_con_t* _h)
|
|
{
|
|
dbcl_cls_t *cls=NULL;
|
|
LM_DBG("executing db cluster close command\n");
|
|
cls = (dbcl_cls_t*)_h->tail;
|
|
cls->ref--;
|
|
if(cls->ref <= 0) {
|
|
/* close connections */
|
|
dbcl_close_connections(cls);
|
|
}
|
|
/* free _h - allocated for each db_cluster_init() */
|
|
pkg_free(_h);
|
|
return;
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Free all memory allocated by get_result
|
|
*/
|
|
int db_cluster_free_result(db1_con_t* _h, db1_res_t* _r)
|
|
{
|
|
dbcl_cls_t *cls=NULL;
|
|
LM_DBG("executing db cluster free-result command\n");
|
|
cls = (dbcl_cls_t*)_h->tail;
|
|
if(cls->usedcon==NULL || cls->usedcon->dbh==NULL)
|
|
return -1;
|
|
return cls->usedcon->dbf.free_result(cls->usedcon->dbh, _r);
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Do a query
|
|
*/
|
|
int db_cluster_query(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _op,
|
|
const db_val_t* _v, const db_key_t* _c, const int _n, const int _nc,
|
|
const db_key_t _o, db1_res_t** _r)
|
|
{
|
|
LM_DBG("executing db cluster query command\n");
|
|
DBCL_READ(query, query(dbh, _k, _op, _v, _c, _n, _nc, _o, _r));
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* fetch rows from a result
|
|
*/
|
|
int db_cluster_fetch_result(const db1_con_t* _h, db1_res_t** _r, const int nrows)
|
|
{
|
|
dbcl_cls_t *cls=NULL;
|
|
LM_DBG("executing db cluster fetch-result command\n");
|
|
cls = (dbcl_cls_t*)_h->tail;
|
|
if(cls->usedcon==NULL || cls->usedcon->dbh==NULL
|
|
|| cls->usedcon->dbf.fetch_result==NULL)
|
|
return -1;
|
|
return cls->usedcon->dbf.fetch_result(cls->usedcon->dbh, _r, nrows);
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Raw SQL query
|
|
*/
|
|
int db_cluster_raw_query(const db1_con_t* _h, const str* _s, db1_res_t** _r)
|
|
{
|
|
LM_DBG("executing db cluster raw query command\n");
|
|
DBCL_READ(raw_query, raw_query(dbh, _s, _r));
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Insert a row into table
|
|
*/
|
|
int db_cluster_insert(const db1_con_t* _h, const db_key_t* _k, const db_val_t* _v, const int _n)
|
|
{
|
|
LM_DBG("executing db cluster insert command\n");
|
|
DBCL_WRITE(insert, insert(dbh, _k, _v, _n));
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Delete a row from table
|
|
*/
|
|
int db_cluster_delete(const db1_con_t* _h, const db_key_t* _k, const
|
|
db_op_t* _o, const db_val_t* _v, const int _n)
|
|
{
|
|
LM_DBG("executing db cluster delete command\n");
|
|
DBCL_WRITE(delete, delete(dbh, _k, _o, _v, _n));
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Update a row in table
|
|
*/
|
|
int db_cluster_update(const db1_con_t* _h, const db_key_t* _k, const db_op_t* _o,
|
|
const db_val_t* _v, const db_key_t* _uk, const db_val_t* _uv, const int _n,
|
|
const int _un)
|
|
{
|
|
LM_DBG("executing db cluster update command\n");
|
|
DBCL_WRITE(update, update(dbh, _k, _o, _v, _uk, _uv, _n, _un));
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Just like insert, but replace the row if it exists
|
|
*/
|
|
int db_cluster_replace(const db1_con_t* _h, const db_key_t* _k,
|
|
const db_val_t* _v, const int _n, const int _un, const int _m)
|
|
{
|
|
LM_DBG("executing db cluster replace command\n");
|
|
DBCL_WRITE(replace, replace(dbh, _k, _v, _n, _un, _m));
|
|
}
|
|
|
|
/*! \brief
|
|
* Returns the last inserted ID
|
|
*/
|
|
int db_cluster_last_inserted_id(const db1_con_t* _h)
|
|
{
|
|
dbcl_cls_t *cls=NULL;
|
|
LM_DBG("executing db cluster last inserted id command\n");
|
|
cls = (dbcl_cls_t*)_h->tail;
|
|
if(cls->usedcon==NULL || cls->usedcon->dbh==NULL
|
|
|| cls->usedcon->dbf.last_inserted_id==NULL)
|
|
return -1;
|
|
return cls->usedcon->dbf.last_inserted_id(cls->usedcon->dbh);
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Returns number of affected rows for last query
|
|
*/
|
|
int db_cluster_affected_rows(const db1_con_t* _h)
|
|
{
|
|
dbcl_cls_t *cls=NULL;
|
|
LM_DBG("executing db cluster affected-rows command\n");
|
|
cls = (dbcl_cls_t*)_h->tail;
|
|
if(cls->usedcon==NULL || cls->usedcon->dbh==NULL
|
|
|| cls->usedcon->dbf.affected_rows==NULL)
|
|
return -1;
|
|
return cls->usedcon->dbf.affected_rows(cls->usedcon->dbh);
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Insert a row into table, update on duplicate key
|
|
*/
|
|
int db_cluster_insert_update(const db1_con_t* _h, const db_key_t* _k, const db_val_t* _v,
|
|
const int _n)
|
|
{
|
|
LM_DBG("executing db cluster insert-update command\n");
|
|
DBCL_WRITE(insert_update, insert_update(dbh, _k, _v, _n));
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Insert a row into table
|
|
*/
|
|
int db_cluster_insert_delayed(const db1_con_t* _h, const db_key_t* _k,
|
|
const db_val_t* _v, const int _n)
|
|
{
|
|
LM_DBG("executing db cluster insert delayed command\n");
|
|
DBCL_WRITE(insert_delayed, insert_delayed(dbh, _k, _v, _n));
|
|
}
|
|
|
|
|
|
/*! \brief
|
|
* Store name of table that will be used by
|
|
* subsequent database functions
|
|
*/
|
|
int db_cluster_use_table(db1_con_t* _h, const str* _t)
|
|
{
|
|
int i;
|
|
int j;
|
|
int ret;
|
|
dbcl_cls_t *cls=NULL;
|
|
|
|
cls = (dbcl_cls_t*)_h->tail;
|
|
|
|
ret = 0;
|
|
LM_DBG("use table (%.*s) - cluster [%.*s]\n",
|
|
_t->len, _t->s, cls->name.len, cls->name.s);
|
|
for(i=DBCL_PRIO_SIZE-1; i>0; i--)
|
|
{
|
|
for(j=0; j<cls->rlist[i].clen; j++)
|
|
{
|
|
if(cls->rlist[i].clist[j] != NULL && cls->rlist[i].clist[j]->flags!=0
|
|
&& cls->rlist[i].clist[j]->dbh != NULL)
|
|
{
|
|
LM_DBG("set read table (%.*s) - cluster [%.*s] (%d/%d)\n",
|
|
_t->len, _t->s, cls->name.len, cls->name.s, i, j);
|
|
ret |= cls->rlist[i].clist[j]->dbf.use_table(cls->rlist[i].clist[j]->dbh, _t);
|
|
}
|
|
}
|
|
for(j=0; j<cls->wlist[i].clen; j++)
|
|
{
|
|
if(cls->wlist[i].clist[j] != NULL && cls->wlist[i].clist[j]->flags!=0
|
|
&& cls->wlist[i].clist[j]->dbh != NULL)
|
|
{
|
|
LM_DBG("set write table (%.*s) - cluster [%.*s] (%d/%d)\n",
|
|
_t->len, _t->s, cls->name.len, cls->name.s, i, j);
|
|
ret |= cls->wlist[i].clist[j]->dbf.use_table(cls->wlist[i].clist[j]->dbh, _t);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
}
|