T_KRHDITable *kr_hdi_table_construct(T_KRShmHDI *shm_hdi, T_KRModule *datamodule)
{
T_KRHDITable *krhditable = kr_calloc(sizeof(T_KRHDITable));
if (krhditable == NULL) {
KR_LOG(KR_LOGERROR, "kr_calloc krhditable failed!");
return NULL;
}
krhditable->ptShmHDIs = shm_hdi;
krhditable->lHDICnt = shm_hdi->lHDIDefCnt;
krhditable->ptHDITable = \
kr_hashtable_new_full(kr_long_hash, kr_long_equal, \
NULL, (KRDestroyNotify )kr_hdi_destruct);
int i = 0;
T_KRHDI *krhdi = NULL;
for (i=0; i<shm_hdi->lHDIDefCnt; ++i) {
krhdi = kr_hdi_construct(&shm_hdi->stShmHDIDef[i], datamodule);
if (krhdi == NULL) {
KR_LOG(KR_LOGERROR, "kr_hdi_construct [%d] failed!", i);
kr_hashtable_destroy(krhditable->ptHDITable);
kr_free(krhditable);
return NULL;
}
kr_hashtable_insert(krhditable->ptHDITable, &krhdi->lHDIId, krhdi);
}
krhditable->tConstructTime = shm_hdi->tLastLoadTime;
return krhditable;
}
T_KRData* kr_data_construct(T_KRParam *ptParam, T_KRModule *ptModule,
KRGetTypeFunc pfGetType, KRGetValueFunc pfGetValue)
{
T_KRData *ptData = kr_malloc(sizeof(T_KRData));
if (ptData == NULL) {
KR_LOG(KR_LOGERROR, "kr_malloc ptData Failed!");
return NULL;
}
ptData->ptModule = ptModule;
ptData->pfGetType = pfGetType;
ptData->pfGetValue = pfGetValue;
ptData->ptItemTable = kr_hashtable_new_full(
(KRHashFunc )kr_string_hash, \
(KREqualFunc )kr_string_equal,\
NULL,
(KRDestroyNotify )kr_data_item_free);
if (ptData->ptItemTable == NULL) {
KR_LOG(KR_LOGERROR, "kr_hashtable_new_full item table Failed!");
return NULL;
}
//load data item according parameter
if (kr_data_item_load(ptData, ptParam) != 0) {
KR_LOG(KR_LOGERROR, "load item table error!");
return NULL;
}
ptData->tConstructTime = kr_param_load_time(ptParam);
return ptData;
}
/* initialize rule detecting context */
T_KRContext *kr_context_init(T_KRContextEnv *ptEnv)
{
T_KRContext *ptContext = kr_calloc(sizeof(T_KRContext));
if (ptContext == NULL) {
KR_LOG(KR_LOGERROR, "kr_calloc ptContext failed!");
return NULL;
}
ptContext->ptEnv = ptEnv;
/* reconnect database in thread */
T_DbsEnv *ptDbsEnv = ((T_KRContextEnv *)ptEnv)->ptDbsEnv;
ptContext->ptDbsEnv = dbsConnect(ptDbsEnv->dsn, ptDbsEnv->user, ptDbsEnv->pass);
if (ptContext->ptDbsEnv == NULL) {
KR_LOG(KR_LOGERROR, "dbsConnect [%s] [%s] [%s] failed!", \
ptDbsEnv->dsn, ptDbsEnv->user, ptDbsEnv->pass);
kr_free(ptContext);
return NULL;
}
/* construct data */
ptContext->ptData = kr_data_construct(ptEnv->ptParam, ptEnv->dataModule,
ptDbsEnv, ptEnv->ptHDICache, kr_data_get_type, kr_data_get_value);
if (ptContext->ptData == NULL) {
KR_LOG(KR_LOGERROR, "kr_data_construct failed!");
dbsDisconnect(ptContext->ptDbsEnv);
kr_free(ptContext);
return NULL;
}
/* construct flow */
return ptContext;
}
/*static dataitem*/
T_KRDDI *kr_ddi_construct(T_KRParamDDIDef *ptParamDDIDef, T_KRModule *ptModule,
KRGetTypeFunc pfGetType, KRGetValueFunc pfGetValue)
{
T_KRDDI *ptDDI = kr_calloc(sizeof(T_KRDDI));
if (ptDDI == NULL) {
KR_LOG(KR_LOGERROR, "kr_calloc ptDDI failed!");
return NULL;
}
ptDDI->ptParamDDIDef = ptParamDDIDef;
ptDDI->lDDIId = ptParamDDIDef->lDdiId;
ptDDI->ptDDICalc = kr_calc_construct(ptParamDDIDef->caDdiFilterFormat[0], \
ptParamDDIDef->caDdiFilterString, pfGetType, pfGetValue);
ptDDI->eValueType = ptParamDDIDef->caDdiValueType[0];
/*get the retrieve data function from module*/
if (ptParamDDIDef->caDdiAggrFunc[0] != '\0') {
ptDDI->pfDDIAggr = (KRDDIAggrFunc )kr_module_symbol(ptModule,
ptParamDDIDef->caDdiAggrFunc);
if (ptDDI->pfDDIAggr == NULL) {
KR_LOG(KR_LOGERROR, "kr_module_symbol [%s] error!", \
ptParamDDIDef->caDdiAggrFunc);
return NULL;
}
}
ptDDI->eValueInd = KR_VALUE_UNSET;
ptDDI->ptRelated = kr_hashtable_new(kr_pointer_hash, kr_pointer_equal);
return ptDDI;
}
static int kr_data_item_load(T_KRData *ptData, T_KRParam *ptParam)
{
//load set
if (kr_param_object_foreach(ptParam, KR_PARAM_SET,
_kr_data_item_set_load, ptData) != 0) {
KR_LOG(KR_LOGERROR, "kr_data_item_set_load Error!");
return -1;
}
//load sdi
if (kr_param_object_foreach(ptParam, KR_PARAM_SDI,
_kr_data_item_sdi_load, ptData) != 0) {
KR_LOG(KR_LOGERROR, "kr_data_item_sdi_load Error!");
return -1;
}
//load ddi
if (kr_param_object_foreach(ptParam, KR_PARAM_DDI,
_kr_data_item_ddi_load, ptData) != 0) {
KR_LOG(KR_LOGERROR, "kr_data_item_ddi_load Error!");
return -1;
}
//load hdi
if (kr_param_object_foreach(ptParam, KR_PARAM_HDI,
_kr_data_item_hdi_load, ptData) != 0) {
KR_LOG(KR_LOGERROR, "kr_data_item_hdi_load Error!");
return -1;
}
return 0;
}
int kr_param_persist_file_load(T_KRParam *ptParam, char *psParamVersion, char *psParamClassName, void *ptResource)
{
int nRet = 0;
cJSON *root = (cJSON *)ptResource;
cJSON *children = cJSON_GetObjectItem(root, psParamClassName);
if (children == NULL) {
KR_LOG(KR_LOGDEBUG, "no param class %s found!", psParamClassName);
return nRet;
}
for (int i=0; i<cJSON_GetArraySize(children); ++i) {
cJSON *child = cJSON_GetArrayItem(children, i);
char *psParamObjectKey = cJSON_GetString(child, "param_object_key");
char *psParamObjectString = cJSON_GetString(child, "param_object_string");
nRet = kr_param_object_add(ptParam, psParamClassName,
psParamObjectKey, psParamObjectString);
if (nRet != 0) {
KR_LOG(KR_LOGERROR, "kr_param_object_add %s failed!", psParamObjectKey);
return -1;
}
}
return nRet;
}
T_KRHDITable *kr_hdi_table_construct(T_KRParamHDI *ptParamHDI, T_KRModule *ptModule)
{
T_KRHDITable *ptHdiTable = kr_calloc(sizeof(T_KRHDITable));
if (ptHdiTable == NULL) {
KR_LOG(KR_LOGERROR, "kr_calloc ptHdiTable failed!");
return NULL;
}
ptHdiTable->ptParamHDI = ptParamHDI;
ptHdiTable->lHDICnt = ptParamHDI->lHDIDefCnt;
ptHdiTable->ptHDITable = \
kr_hashtable_new_full(kr_long_hash, kr_long_equal, \
NULL, (KRDestroyNotify )kr_hdi_destruct);
int i = 0;
T_KRHDI *ptHDI = NULL;
for (i=0; i<ptParamHDI->lHDIDefCnt; ++i) {
ptHDI = kr_hdi_construct(&ptParamHDI->stParamHDIDef[i], ptModule);
if (ptHDI == NULL) {
KR_LOG(KR_LOGERROR, "kr_hdi_construct [%d] failed!", i);
kr_hashtable_destroy(ptHdiTable->ptHDITable);
kr_free(ptHdiTable);
return NULL;
}
kr_hashtable_insert(ptHdiTable->ptHDITable, &ptHDI->lHDIId, ptHDI);
}
ptHdiTable->tConstructTime = ptParamHDI->tLastLoadTime;
return ptHdiTable;
}
int kr_coordi_handle_clioff(T_KREventLoop *el, int fd, T_KRMessage *krmsg)
{
KR_LOG(KR_LOGDEBUG, "Client [%s] Offline [%d]!", krmsg->clientid, fd);
/* Check this client whether exists */
T_KRListNode *node = kr_list_search(krcoordi.clients, krmsg->clientid);
if (node == NULL) {
KR_LOG(KR_LOGDEBUG, "Client %s not exists!", krmsg->clientid);
return 0;
}
/*remove from list*/
T_KRCoordiConnector *ptClient = (T_KRCoordiConnector *)node->value;
kr_list_remove(krcoordi.clients, ptClient->id);
/* remove from fdtable */
kr_hashtable_remove(krcoordi.fdtable, &fd);
/* Free this client */
kr_event_file_delete(el, fd, KR_EVENT_READABLE);
close(fd);
kr_free(ptClient);
return 0;
}
int ERMHandle(int iDataSrc, void *ptReqDef)
{
int iResult = 0;
/* 插入KRDB内存数据库 */
gstContext.ptCurrRec = kr_db_insert(gstContext.ptKRDB, iDataSrc, ptReqDef);
if (gstContext.ptCurrRec == NULL)
{
KR_LOG(KR_LOGERROR, "kr_db_insert Failed!");
return -1;
}
KR_LOG(KR_LOGDEBUG, "0.kr_db_insert [%d] Passed!", iDataSrc);
/* 规则侦测 */
iResult = kr_rule_group_detect(ptDynMem, &gstContext);
if (iResult != 0)
{
KR_LOG(KR_LOGERROR, "kr_rule_group_detect Failed!");
return -1;
}
KR_LOG(KR_LOGDEBUG, "1.kr_rule_group_detect [%d] Passed!", iDataSrc);
/*DumpDataVal(stdout, &gptDataVal);*/
return 0;
}
int kr_coordi_handle_reply(T_KREventLoop *el, int fd, T_KRMessage *krmsg)
{
KR_LOG(KR_LOGDEBUG, "Client [%s] Got Reply[%s] From Server [%s]!", \
krmsg->clientid, krmsg->msgid, krmsg->serverid);
/* Check this server whether allowed */
T_KRActualNode *server = NULL;
server = kr_conhash_lookup(krcoordi.servers, krmsg->serverid);
if (server == NULL) {
KR_LOG(KR_LOGERROR, "Server %s not allowed!", krmsg->serverid);
return -1;
}
T_KRCoordiConnector *ptServer = (T_KRCoordiConnector *)server->priv;
++ptServer->rplnum;
/* Check this client whether exists */
T_KRListNode *node = kr_list_search(krcoordi.clients, krmsg->clientid);
if (node == NULL) {
KR_LOG(KR_LOGERROR, "Client %s not exists!", krmsg->clientid);
return -1;
}
T_KRCoordiConnector *ptClient = (T_KRCoordiConnector *)node->value;
/*send reply to client*/
int writeLen = kr_message_write(ptClient->fd, krmsg);
if (writeLen <= 0) {/* write message failure */
KR_LOG(KR_LOGERROR, "write message error[%s]!", krcoordi.neterr);
strcpy(ptClient->neterr, krcoordi.neterr);
++ptClient->errnum;
return -1;
}
++ptClient->rplnum;
return 0;
}
int ERMInitial(void)
{
//Step 1:kr_db_startup
gstContext.ptKRDB = kr_db_startup("ERM_KRDB");
if (gstContext.ptKRDB == NULL)
{
KR_LOG(KR_LOGERROR, "kr_db_startup Failed!");
return -1;
}
//kr_db_load(gptKRDB);
//Step 3: kr_shm_attach
gstContext.ptShm = kr_shm_attach(74561);
if (gstContext.ptShm == NULL) {
KR_LOG(KR_LOGERROR, "Attach ShareMemory Failed!");
return -1;
}
ptDynMem = kr_dym_construct(gptShmBuf);
if (ptDynMem == NULL)
{
KR_LOG(KR_LOGERROR, "kr_dym_construct Failed!");
return -1;
}
return 0;
}
T_KROutput* kr_output_construct(T_KRParam *ptParam, char *psOutputModule,
KRGetTypeFunc pfGetType, KRGetValueFunc pfGetValue)
{
T_KROutput *ptOutput = kr_calloc(sizeof(*ptOutput));
if (ptOutput == NULL) {
KR_LOG(KR_LOGERROR, "kr_calloc ptOutput failed!");
return NULL;
}
/* load output module */
ptOutput->ptOutputModule = kr_module_open(psOutputModule, RTLD_LAZY);
if (ptOutput->ptOutputModule == NULL) {
KR_LOG(KR_LOGERROR, "kr_module_open %s failed!", psOutputModule);
kr_output_destruct(ptOutput);
return NULL;
}
ptOutput->pfGetType = pfGetType;
ptOutput->pfGetValue = pfGetValue;
/*alloc output define list*/
ptOutput->ptOutputDefineList = kr_list_new();
kr_list_set_match(ptOutput->ptOutputDefineList, (KRListMatchFunc )kr_output_define_match);
kr_list_set_free(ptOutput->ptOutputDefineList, (KRListFreeFunc )kr_output_define_free);
/*create output list*/
if (kr_param_object_foreach(ptParam, KR_PARAM_OUTPUT,
_kr_output_define_new, ptOutput) != 0) {
KR_LOG(KR_LOGERROR, "_kr_db_build_table Error!");
return NULL;
}
ptOutput->tConstructTime = kr_param_load_time(ptParam);
return ptOutput;
}
int kr_coordi_handle_svroff(T_KREventLoop *el, int fd, T_KRMessage *krmsg)
{
KR_LOG(KR_LOGDEBUG, "Server [%s] Offline [%d]!", krmsg->serverid, fd);
/* Check this server whether exists */
T_KRActualNode *node = \
kr_conhash_lookup(krcoordi.servers, krmsg->serverid);
if (node == NULL) {
KR_LOG(KR_LOGDEBUG, "Server %s not exists!", krmsg->serverid);
return 0;
}
/* remove from fdtable */
kr_hashtable_remove(krcoordi.fdtable, &fd);
/* remove from conhash */
T_KRCoordiConnector *ptServer = (T_KRCoordiConnector *)node->priv;
kr_conhash_remove(krcoordi.servers, ptServer->id);
/* Free this server */
kr_event_file_delete(el, fd, KR_EVENT_READABLE);
close(fd);
kr_free(ptServer);
return 0;
}
static int kr_server_try_connect_to_cluster(void)
{
if (krserver.coordport != 0) {
krserver.cofd = kr_net_tcp_connect(krserver.neterr, \
krserver.coordip, krserver.coordport);
if (krserver.cofd == KR_NET_ERR) {
KR_LOG(KR_LOGERROR, "kr_net_tcp_connect[%s][%d] failed[%s]",
krserver.coordip, krserver.coordport, krserver.neterr);
return -1;
}
}
if (krserver.cofd < 0) {
KR_LOG(KR_LOGERROR, "Can't connect to coordinator in cluster!");
return -1;
}
/* write svron message to the cluster */
if (kr_server_handle_svron() != 0) {
KR_LOG(KR_LOGERROR, "kr_server_handle_svron cluster!");
return -1;
}
/* Register read file event */
if (kr_event_file_create(krserver.krel, krserver.cofd, KR_EVENT_READABLE, \
kr_server_message_read_handler, NULL) == KR_NET_ERR) {
KR_LOG(KR_LOGERROR, "kr_event_file_create failed[%s]", krserver.neterr);
return -1;
}
return 0;
}
static T_KRDataItem *kr_data_item_get(T_KRData *ptData, char kind, int id, T_KRContext *ptContext)
{
char caDataItemId[20+1] = {0};
snprintf(caDataItemId, sizeof(caDataItemId), "%c_%d", kind, id);
T_KRDataItem *ptDataItem = kr_hashtable_lookup(ptData->ptItemTable, caDataItemId);
if (ptDataItem == NULL) {
KR_LOG(KR_LOGERROR, "kr_hashtable_lookup [%c]:[%d] failed!", kind, id);
return NULL;
}
//check whether computed yet, that is record level cache
T_KRRecord *ptCurrRec = kr_context_get_data(ptContext, "curr_rec");
if (ptDataItem->ptCurrRec != ptCurrRec) {
ptDataItem->ptCurrRec = ptCurrRec;
if (ptDataItem->pfDataItemAggr != NULL) {
if (ptDataItem->pfDataItemAggr(ptDataItem, ptContext) != 0) {
KR_LOG(KR_LOGERROR, "pfDataItemAggr [%c]:[%d] failed!",
kind, id);
return NULL;
}
}
} else {
KR_LOG(KR_LOGDEBUG, "Get [%c]:[%d] record level cached!", kind, id);
}
return ptDataItem;
}
T_KRRecord *kr_input_process(T_KRInput *ptInput, T_KRRequest *ptRequest)
{
char *msgid = ptRequest->msgid;
int msgsrc = ptRequest->msgsrc;
char *msgfmt = ptRequest->msgfmt;
size_t msglen = ptRequest->msglen;
char *msgbuf = ptRequest->msgbuf;
T_KRInputDefine *ptInputDefine = kr_input_get_define(ptInput, msgsrc);
if (ptInputDefine == NULL) {
KR_LOG(KR_LOGERROR, "kr_input_get_define [%d] error!", msgsrc);
return NULL;
}
T_KRInputHandle *ptInputHandle = kr_input_define_get_handle(ptInputDefine, msgfmt, ptInput->ptInputModule);
if (ptInputHandle == NULL) {
KR_LOG(KR_LOGERROR, "kr_input_define_get_handle [%s] error!", msgfmt);
return NULL;
}
T_KRRecord *ptRecord = kr_record_new(ptInput, msgsrc);
if (ptRecord == NULL) {
KR_LOG(KR_LOGERROR, "kr_record_new [%s] error!", msgsrc);
return NULL;
}
int iResult = kr_input_handle_process(ptInputHandle, ptInputDefine, msglen, msgbuf, ptRecord);
if (iResult != 0) {
KR_LOG(KR_LOGERROR, "kr_input_handle_process [%s] error!", msgid);
kr_record_free(ptRecord);
return NULL;
}
return ptRecord;
}
void
kr_coordi_tcp_accept_handler(T_KREventLoop *el, int fd, void *priv, int mask)
{
int cport, cfd;
char cip[128];
cfd = kr_net_tcp_accept(krcoordi.neterr, fd, cip, &cport);
if (cfd == KR_NET_ERR) {
KR_LOG(KR_LOGERROR, "Accepting client connection: %s", krcoordi.neterr);
return;
}
KR_LOG(KR_LOGDEBUG, "Accepted tcp/ip connection %s:%d", cip, cport);
kr_coordi_common_accept_handler(cfd);
}
int kr_coordi_handle_apply(T_KREventLoop *el, int fd, T_KRMessage *krmsg)
{
KR_LOG(KR_LOGDEBUG, "Client [%s] Send Apply[%s] To Server [%s]!", \
krmsg->clientid, krmsg->msgid, krmsg->serverid);
/* Check this client whether allowed */
T_KRListNode *node = kr_list_search(krcoordi.clients, krmsg->clientid);
if (node == NULL) {
KR_LOG(KR_LOGERROR, "Client %s not allowed!", krmsg->clientid);
return -1;
}
T_KRCoordiConnector *ptClient = (T_KRCoordiConnector *)node->value;
++ptClient->aplnum;
T_KRActualNode *server = NULL;
/*if apply message specified the destination server*/
if (krmsg->serverid[0] != '\0') {
/* Check this server whether exists */
server = kr_conhash_lookup(krcoordi.servers, krmsg->serverid);
if (server == NULL) {
KR_LOG(KR_LOGDEBUG, "Specified Server [%s] doesn't exists!", \
krmsg->serverid);
}
}
/*choose server according to the key*/
if (server == NULL) {
server = kr_conhash_locate(krcoordi.servers, krmsg->msgid);
if (server == NULL) {
KR_LOG(KR_LOGERROR, "kr_conhash_locate %s failed!", \
krmsg->msgid);
return -1;
}
}
/* padding serverid field */
T_KRCoordiConnector *ptServer = (T_KRCoordiConnector *)server->priv;
strcpy(krmsg->serverid, ptServer->id);
++ptServer->aplnum;
KR_LOG(KR_LOGDEBUG, "Located Server [%s] with Consistent hashing [%s]!", \
krmsg->serverid, krmsg->msgid);
/* send to the one who's the specified or need replication */
kr_conhash_foreach_node(krcoordi.servers, \
(KRForEachFunc )kr_coordi_send_to_server, krmsg);
return 0;
}
void *kr_data_get_value(T_KRData *ptData, char kind, int id, T_KRContext *ptContext)
{
T_KRDataItem *ptDataItem = kr_data_item_get(ptData, kind, id, ptContext);
if (ptDataItem == NULL) {
KR_LOG(KR_LOGERROR, "kr_data_item_get [%c]:[%d] failed!", kind, id);
return NULL;
}
if (ptDataItem->eValueInd != KR_VALUE_SETED) {
KR_LOG(KR_LOGERROR, "[%c]:[%d] value unset!", kind, id);
return NULL;
}
return kr_get_value(&ptDataItem->uValue, ptDataItem->eValueType);
}
E_KRType kr_data_get_type(T_KRData *ptData, char kind, int id, T_KRContext *ptContext)
{
T_KRDataItem *ptDataItem = kr_data_item_get(ptData, kind, id, ptContext);
if (ptDataItem == NULL) {
KR_LOG(KR_LOGERROR, "kr_data_item_get [%c]:[%d] failed!", kind, id);
return KR_TYPE_UNKNOWN;
}
if (ptDataItem->eValueInd != KR_VALUE_SETED) {
KR_LOG(KR_LOGERROR, "[%c]:[%d] value unset!", kind, id);
return KR_TYPE_UNKNOWN;
}
return ptDataItem->eValueType;
}
int kr_group_func(T_KRGroup *krgroup, T_KRContext *krcontext)
{
/*add alert info*/
cJSON *alert = cJSON_CreateObject();
cJSON_AddNumberToObject(alert, "groupid", krgroup->lGroupId);
/*add current record info*/
cJSON *currec = cJSON_CreateObject();
_set_cjson_record(krcontext->ptCurrRec, currec);
cJSON_AddItemToObject(alert, "currec", currec);
/*add rules info*/
cJSON *rules = cJSON_CreateArray();
kr_list_foreach(krgroup->ptRuleList->ptRuleList, (KRForEachFunc )_add_rule, rules);
cJSON_AddItemToObject(alert, "rules", rules);
/*add dataitems info*/
cJSON *datas = cJSON_CreateObject();
T_KRHashTable *sditable = krcontext->ptDym->sditable->ptSDITable;
_add_sdis_to_data(sditable, datas);
T_KRHashTable *dditable = krcontext->ptDym->dditable->ptDDITable;
_add_ddis_to_data(dditable, datas);
T_KRHashTable *hditable = krcontext->ptDym->hditable->ptHDITable;
_add_hdis_to_data(hditable, datas);
cJSON_AddItemToObject(alert, "datas", datas);
krcontext->pcaResp = cJSON_PrintUnformatted(alert);
cJSON_Delete(alert);
/*Important: You need kr_free Response*/
printf("response: %s\n", krcontext->pcaResp);
KR_LOG(KR_LOGDEBUG, "response : %s ", krcontext->pcaResp);
return 0;
}
int ERMFinish(void)
{
int iResult = 0;
kr_dym_destruct(ptDynMem);
/* kr_shm_detach */
kr_shm_detach(gstContext.ptShm);
/* kr_db_dump */
FILE *fpKRDBDump = NULL;
char caDateTime[14+1] = {0};
char caKRDBDumpFileName[1024]= {0};
snprintf(caKRDBDumpFileName, sizeof(caKRDBDumpFileName), \
"KRDB.%s.Dump", kr_time_system(caDateTime));
if ((fpKRDBDump = fopen(caKRDBDumpFileName, "w")) != NULL)
{
kr_db_dump(gstContext.ptKRDB, 0, fpKRDBDump);
fclose(fpKRDBDump);
}
// kr_db_shutdown
iResult = kr_db_shutdown(gstContext.ptKRDB);
if (iResult != 0)
{
KR_LOG(KR_LOGERROR, "kr_db_shutdown Failed!");
return -1;
}
return 0;
}
static int _kr_data_item_hdi_load(char *psParamClassName,
char *psParamObjectKey, char *psParamObjectString,
void *ptParamObject, void *data)
{
T_KRParamHdi *ptParamHdi = (T_KRParamHdi *)ptParamObject;
T_KRData *ptData = (T_KRData *)data;
T_KRDataItem *ptDataItem = kr_data_item_new(
ptParamHdi,
ptParamHdi->caHdiName[0], //FIXME:
ptParamHdi->lHdiId,
ptData->pfGetType,
ptData->pfGetValue,
kr_data_item_hdi_new,
kr_data_item_hdi_aggr,
kr_data_item_hdi_free);
if (ptDataItem == NULL) {
KR_LOG(KR_LOGERROR, "kr_data_item_create [%ld] failed!", \
ptParamHdi->lHdiId);
return -1;
}
//insert into item table
kr_hashtable_replace(ptData->ptItemTable, ptDataItem->caDataItemId, ptDataItem);
return 0;
}
int kr_data_check(T_KRData *ptData, T_KRParam *ptParam)
{
/*check item table*/
if (ptData->tConstructTime != kr_param_load_time(ptParam)) {
KR_LOG(KR_LOGDEBUG, "reload ...[%ld][%ld]",
ptData->tConstructTime, kr_param_load_time(ptParam));
kr_hashtable_remove_all(ptData->ptItemTable);
if (kr_data_item_load(ptData, ptParam) != 0) {
KR_LOG(KR_LOGERROR, "reload item table error!");
return -1;
}
}
return 0;
}
T_KRCache *kr_hdi_cache_create(unsigned int cache_size)
{
T_KRCache *cache = kr_cache_new(cache_size,
(KRHashFunc )kr_string_hash,
(KREqualFunc )kr_string_equal,
(KRDupFunc )kr_strdup, kr_free,
NULL, (KRFreeFunc )kr_hashtable_destroy,
(KRFunc )kr_hdi_cache_node_dump);
if (cache == NULL) {
KR_LOG(KR_LOGERROR, "kr_cache_new [%u] Failed!", cache_size);
return NULL;
}
KR_LOG(KR_LOGDEBUG, "HDI Cache [%u] has been created!", cache_size);
return cache;
}
void *kr_data_item_ddi_new(T_KRDataItem *ptDataItem)
{
T_KRParamDdi *ptParamDdi = (T_KRParamDdi *)ptDataItem->ptDataItemDef;
T_KRDdi *ptDdi = kr_calloc(sizeof(*ptDdi));
if (ptDdi == NULL) {
KR_LOG(KR_LOGERROR, "kr_calloc ptDdi failed!");
return NULL;
}
ptDdi->ptFilterCalc = kr_calc_construct(
ptParamDdi->caDdiFilterFormat[0], \
ptParamDdi->caDdiFilterString, \
ptDataItem->pfGetType, \
ptDataItem->pfGetValue);
if (ptDdi->ptFilterCalc == NULL) {
KR_LOG(KR_LOGERROR, "kr_calc_construct filter failed!");
return NULL;
}
/*
ptDdi->ptResultCalc = kr_calc_construct(
ptParamSdi->caSdiResultFormat[0], \
ptParamSdi->caSdiResultString, \
ptDataItem->pfGetType, \
ptDataItem->pfGetValue);
if (ptDdi->ptResultCalc == NULL) {
KR_LOG(KR_LOGERROR, "kr_calc_construct result failed!");
return NULL;
}
*/
ptDdi->ptRelated = kr_hashtable_new(kr_pointer_hash, kr_pointer_equal);
if (ptDdi->ptRelated == NULL) {
KR_LOG(KR_LOGERROR, "kr_hashtable_new related failed!");
return NULL;
}
ptDataItem->ptPrivate = ptDdi;
return ptDdi;
}
int kr_output_check(T_KROutput* ptOutput, T_KRParam *ptParam)
{
/*check output param*/
if (ptOutput->tConstructTime != kr_param_load_time(ptParam)) {
KR_LOG(KR_LOGDEBUG, "reload output ...[%ld][%ld]",
ptOutput->tConstructTime, kr_param_load_time(ptParam));
//TODO:reconstruct ptOutput
}
return 0;
}
/* initialize rule detecting context */
T_KRContext *kr_context_init(T_KRContextEnv *ptEnv)
{
T_KRContext *ptContext = kr_calloc(sizeof(T_KRContext));
if (ptContext == NULL) {
KR_LOG(KR_LOGERROR, "kr_calloc ptContext failed!");
return NULL;
}
ptContext->ptEnv = ptEnv;
/* reconnect database in thread */
T_DbsEnv *dbsenv = ((T_KRContextEnv *)ptEnv)->ptDbs;
ptContext->ptDbs = dbsConnect(dbsenv->dsn, dbsenv->user, dbsenv->pass);
if (ptContext->ptDbs == NULL) {
KR_LOG(KR_LOGERROR, "dbsConnect [%s] [%s] [%s] failed!", \
dbsenv->dsn, dbsenv->user, dbsenv->pass);
kr_free(ptContext);
return NULL;
}
ptContext->ptArg = kr_calloc(sizeof(T_KRContextArg));
if (ptContext->ptArg == NULL) {
KR_LOG(KR_LOGERROR, "kr_calloc ptContext->ptArg failed!");
dbsDisconnect(ptContext->ptDbs);
kr_free(ptContext);
return NULL;
}
ptContext->ptDym = kr_dynamicmem_init(ptEnv->ptShm, \
ptEnv->dataModule, ptEnv->ruleModule);
if (ptContext->ptDym == NULL) {
KR_LOG(KR_LOGERROR, "kr_dynamicmem_init failed!");
dbsDisconnect(ptContext->ptDbs);
kr_free(ptContext->ptArg);
kr_free(ptContext);
return NULL;
}
return ptContext;
}
static void
kr_coordi_read_handler(T_KREventLoop *el, int fd, void *priv, int mask)
{
int ret = 0;
T_KRMessage stMsg = {0};
/** read message */
T_KRMessage *ptMsg = kr_message_read(fd);
if (ptMsg == NULL) {
/* read message failure */
KR_LOG(KR_LOGERROR, "read message error[%s]!", krcoordi.neterr);
T_KRCoordiConnector *ptConn = NULL;
/* find server or client with fd, then free it */
ptConn = kr_hashtable_lookup(krcoordi.fdtable, &fd);
if (ptConn == NULL) {
kr_event_file_delete(el, fd, KR_EVENT_READABLE);
close(fd);
return;
}
/* handle it as connector offline */
if (ptConn->role == KR_COORDI_SERVER) {
stMsg.msgtype = KR_MSGTYPE_SVROFF;
strcpy(stMsg.serverid, ptConn->id);
} else {
stMsg.msgtype = KR_MSGTYPE_CLIOFF;
strcpy(stMsg.clientid, ptConn->id);
}
ptMsg = &stMsg;
}
/** handle message */
ret = kr_coordi_handle_message(el, fd, ptMsg);
if (ret != 0) {/* handle message failure */
KR_LOG(KR_LOGERROR, "handle message [%d], [%s]error!", \
ptMsg->msgtype, ptMsg->msgbuf);
return;
}
}
/*data item*/
T_KRDataItem *kr_data_item_new(void *ptDataItemDef, char kind, int id,
KRGetTypeFunc pfGetType, KRGetValueFunc pfGetValue,
KRDataItemNewFunc pfDataItemNew,
KRDataItemAggrFunc pfDataItemAggr,
KRDataItemFreeFunc pfDataItemFree)
{
T_KRDataItem *ptDataItem = kr_calloc(sizeof(T_KRDataItem));
if (ptDataItem == NULL) {
KR_LOG(KR_LOGERROR, "kr_calloc ptDataItem failed!");
return NULL;
}
ptDataItem->ptDataItemDef = ptDataItemDef;
ptDataItem->cDataItemKind = kind;
ptDataItem->lDataItemId = id;
ptDataItem->pfGetType = pfGetType;
ptDataItem->pfGetValue = pfGetValue;
ptDataItem->pfDataItemNew = pfDataItemNew;
ptDataItem->pfDataItemAggr = pfDataItemAggr;
ptDataItem->pfDataItemFree = pfDataItemFree;
snprintf(ptDataItem->caDataItemId, sizeof(ptDataItem->caDataItemId),
"%c_%d", kind, id);
//initialize variable
ptDataItem->ptCurrRec = NULL;
ptDataItem->eValueInd == KR_VALUE_UNSET;
//new private data if new function specified
if (ptDataItem->pfDataItemNew != NULL) {
ptDataItem->ptPrivate = ptDataItem->pfDataItemNew(ptDataItem);
if (ptDataItem->ptPrivate == NULL) {
KR_LOG(KR_LOGERROR, "call pfDataItemNew failed!");
kr_free(ptDataItem);
return NULL;
}
}
return ptDataItem;
}
