00001
00002
00003 #include "reGlobals.h"
00004 #include "initServer.h"
00005 #include "reHelpers1.h"
00006 #include "apiHeaderAll.h"
00007 #include "parser.h"
00008 #include "index.h"
00009 #include "rules.h"
00010 #include "cache.h"
00011 #include "locks.h"
00012 #include "functions.h"
00013 #include "configuration.h"
00014 #ifndef USE_EIRODS
00015 #include "reAction.h"
00016 #endif
00017
00018
00019
00020
00021
00022 #ifdef MYMALLOC
00023 # Within reLib1.c here, change back the redefines of malloc back to normal
00024 #define malloc(x) malloc(x)
00025 #define free(x) free(x)
00026 #endif
00027
00028 int processReturnRes(Res *res);
00029
00030 int
00031 applyRuleArg(char *action, char *args[MAX_NUM_OF_ARGS_IN_ACTION], int argc,
00032 ruleExecInfo_t *rei, int reiSaveFlag)
00033 {
00034 #ifdef DEBUG
00035 writeToTmp("entry.log", "applyRuleArg: ");
00036 writeToTmp("entry.log", action);
00037 writeToTmp("entry.log", "(pass on to applyRulePA)\n");
00038 #endif
00039 msParamArray_t *inMsParamArray = NULL;
00040 int i;
00041
00042 i = applyRuleArgPA(action ,args, argc, inMsParamArray, rei, reiSaveFlag);
00043 return(i);
00044 }
00045
00046
00047
00048
00049
00050 int
00051 applyRuleArgPA(char *action, char *args[MAX_NUM_OF_ARGS_IN_ACTION], int argc,
00052 msParamArray_t *inMsParamArray, ruleExecInfo_t *rei, int reiSaveFlag)
00053 {
00054 #ifdef DEBUG
00055 writeToTmp("entry.log", "applyRuleArgPa: ");
00056 writeToTmp("entry.log", action);
00057 writeToTmp("entry.log", "\n");
00058 #endif
00059 int i;
00060
00061 Region *r = make_region(0, NULL);
00062 rError_t errmsgBuf;
00063 errmsgBuf.errMsg = NULL;
00064 errmsgBuf.len = 0;
00065 Res *res = computeExpressionWithParams(action, args, argc, rei, reiSaveFlag, inMsParamArray, &errmsgBuf, r);
00066 i = processReturnRes(res);
00067 region_free(r);
00068
00069 #if 0
00070
00071 if (i == 0) {
00072 for (i = 0; i < argc ; i++) {
00073 if ((mP = getMsParamByLabel (inMsParamArray, args[i])) != NULL)
00074 strcpy(args[i], (char *) mP->inOutStruct);
00075
00076 }
00077 i = 0;
00078 }
00079
00080 #endif
00081 if(i<0) {
00082 logErrMsg(&errmsgBuf, &rei->rsComm->rError);
00083 }
00084 freeRErrorContent(&errmsgBuf);
00085 return(i);
00086
00087 }
00088
00089
00090 int processReturnRes(Res *res) {
00091 int ret;
00092 if(res->nodeType == N_ERROR) {
00093 ret = RES_ERR_CODE(res);
00094 } else {
00095 switch(TYPE(res)) {
00096 case T_INT:
00097 ret = RES_INT_VAL(res);
00098 break;
00099 default:
00100 ret = 0;
00101 break;
00102 }
00103 }
00104
00105 return ret;
00106 }
00107 int computeExpression(char *inAction, msParamArray_t *inMsParamArray, ruleExecInfo_t *rei, int reiSaveFlag, char *res) {
00108 #ifdef DEBUG
00109 writeToTmp("entry.log", "computeExpression: ");
00110 writeToTmp("entry.log", inAction);
00111 writeToTmp("entry.log", "\n");
00112 #endif
00113
00114 Region *r = make_region(0, NULL);
00115
00116 Res *res0 = parseAndComputeExpressionAdapter(inAction, inMsParamArray, 0, rei, reiSaveFlag, r);
00117 int ret;
00118 char *res1 = convertResToString(res0);
00119 snprintf(res, MAX_COND_LEN, "%s", res1);
00120 free(res1);
00121
00122 if(getNodeType(res0) == N_ERROR) {
00123 ret = RES_ERR_CODE(res0);
00124 } else {
00125 switch(TYPE(res0)) {
00126 case T_INT:
00127 ret = RES_INT_VAL(res0);
00128 break;
00129 case T_BOOL:
00130 ret = !RES_BOOL_VAL(res0);
00131 break;
00132 default:
00133 ret = 0;
00134 break;
00135 }
00136 }
00137 region_free(r);
00138
00139 return ret;
00140 }
00141
00142
00143
00144
00145 int
00146 applyRule(char *inAction, msParamArray_t *inMsParamArray,
00147 ruleExecInfo_t *rei, int reiSaveFlag)
00148 {
00149 #if defined(DEBUG) || defined(RE_LOG_RULES_TMP)
00150 writeToTmp("entry.log", "applyRule: ");
00151 writeToTmp("entry.log", inAction);
00152 writeToTmp("entry.log", "\n");
00153 #endif
00154 if (GlobalREAuditFlag > 0)
00155 reDebug("ApplyRule", -1, "", inAction,NULL,NULL,rei);
00156
00157 Region *r = make_region(0, NULL);
00158
00159 int ret;
00160 Res *res;
00161 if(inAction[strlen(inAction)-1]=='|') {
00162 char *inActionCopy = strdup(inAction);
00163 inActionCopy[strlen(inAction) - 1] = '\0';
00164 char *action = (char *) malloc(sizeof(char) * strlen(inAction) + 3);
00165 sprintf(action, "{%s}", inActionCopy);
00166 res = parseAndComputeExpressionAdapter(action, inMsParamArray, 0, rei, reiSaveFlag, r);
00167 free(action);
00168 free(inActionCopy);
00169 } else {
00170 res = parseAndComputeExpressionAdapter(inAction, inMsParamArray, 0, rei, reiSaveFlag, r);
00171 }
00172 ret = processReturnRes(res);
00173 region_free(r);
00174 if (GlobalREAuditFlag > 0)
00175 reDebug("ApplyRule", -1, "Done", inAction,NULL,NULL,rei);
00176
00177 return ret;
00178
00179 }
00180
00181
00182 int
00183 applyRuleUpdateParams(char *inAction, msParamArray_t *inMsParamArray,
00184 ruleExecInfo_t *rei, int reiSaveFlag)
00185 {
00186 #ifdef DEBUG
00187 writeToTmp("entry.log", "applyRule: ");
00188 writeToTmp("entry.log", inAction);
00189 writeToTmp("entry.log", "\n");
00190 #endif
00191 if (GlobalREAuditFlag > 0)
00192 reDebug("ApplyRule", -1, "", inAction,NULL,NULL,rei);
00193
00194 Region *r = make_region(0, NULL);
00195
00196 int ret;
00197 Res *res;
00198 res = parseAndComputeExpressionAdapter(inAction, inMsParamArray, 1, rei, reiSaveFlag, r);
00199 ret = processReturnRes(res);
00200 region_free(r);
00201 if (GlobalREAuditFlag > 0)
00202 reDebug("ApplyRule", -1, "Done", inAction,NULL,NULL,rei);
00203
00204 return ret;
00205
00206 }
00207
00208
00209
00210
00211
00212
00213
00214 int
00215 applyAllRules(char *inAction, msParamArray_t *inMsParamArray,
00216 ruleExecInfo_t *rei, int reiSaveFlag, int allRuleExecFlag)
00217 {
00218 #ifdef DEBUG
00219 writeToTmp("entry.log", "applyAllRules: ");
00220 writeToTmp("entry.log", inAction);
00221 writeToTmp("entry.log", "(set GlobalAllRuleExecFlag and forward to applyRule)\n");
00222 #endif
00223
00224
00225 int tempFlag = GlobalAllRuleExecFlag;
00226
00227 GlobalAllRuleExecFlag = allRuleExecFlag == 1? 2 : 1;
00228
00229 if (GlobalREAuditFlag > 0)
00230 reDebug("ApplyAllRules", -1, "", inAction,NULL, NULL,rei);
00231
00232 int ret = applyRule(inAction, inMsParamArray, rei, reiSaveFlag);
00233 if (GlobalREAuditFlag > 0)
00234 reDebug("ApplyAllRules", -1, "Done", inAction,NULL,NULL,rei);
00235
00236
00237 GlobalAllRuleExecFlag = tempFlag;
00238 return ret;
00239 }
00240
00241 int
00242 execMyRule(char * ruleDef, msParamArray_t *inMsParamArray, char *outParamsDesc,
00243 ruleExecInfo_t *rei)
00244 {
00245
00246 return execMyRuleWithSaveFlag(ruleDef, inMsParamArray, outParamsDesc, rei, 0);
00247 }
00248 void appendOutputToInput(msParamArray_t *inpParamArray, char **outParamNames, int outParamN) {
00249 int i, k, repeat = 0;
00250 for(i=0;i<outParamN;i++) {
00251 if(strcmp(outParamNames[i], ALL_MS_PARAM_KW)==0) {
00252 continue;
00253 }
00254 repeat = 0;
00255 for(k=0;k<inpParamArray->len;k++) {
00256 if(inpParamArray->msParam[k]->label!=NULL && strcmp(outParamNames[i], inpParamArray->msParam[k]->label) == 0) {
00257 repeat = 1;
00258 break;
00259 }
00260 }
00261 if(!repeat) {
00262 addMsParam (inpParamArray, outParamNames[i], NULL, NULL, NULL);
00263 }
00264 }
00265
00266 }
00267 int extractVarNames(char **varNames, char *outBuf) {
00268 int n = 0;
00269 char *p = outBuf;
00270 char *psrc = p;
00271
00272 for(;;) {
00273 if(*psrc == '%') {
00274 *psrc = '\0';
00275 varNames[n++] = strdup(p);
00276 *psrc = '%';
00277 p = psrc+1;
00278 } else if(*psrc == '\0') {
00279 if(strlen(p) != 0) {
00280 varNames[n++] = strdup(p);
00281 }
00282 break;
00283 }
00284 psrc++;
00285 }
00286 return n;
00287 }
00288
00289 int
00290 execMyRuleWithSaveFlag(char * ruleDef, msParamArray_t *inMsParamArray, char *outParamsDesc,
00291 ruleExecInfo_t *rei,int reiSaveFlag)
00292
00293 {
00294 int status;
00295 if (GlobalREAuditFlag)
00296 reDebug("ExecMyRule", -1, "", ruleDef,NULL, NULL,rei);
00297
00298 char *outParamNames[MAX_PARAMS_LEN];
00299 int n = extractVarNames(outParamNames, outParamsDesc);
00300 appendOutputToInput(inMsParamArray, outParamNames, n);
00301
00302
00303
00304 int i;
00305 for(i = 0; i < n; i++) {
00306 free(outParamNames[i]);
00307 }
00308
00309 Region *r = make_region(0, NULL);
00310 status =
00311 parseAndComputeRuleAdapter(ruleDef, inMsParamArray, rei, reiSaveFlag, r);
00312 region_free(r);
00313 if (status < 0) {
00314 rodsLog (LOG_NOTICE,"execMyRule %s Failed with status %i",ruleDef, status);
00315 }
00316
00317 if (GlobalREAuditFlag)
00318 reDebug("ExecMyRule", -1, "Done", ruleDef,NULL, NULL,rei);
00319 return(status);
00320 }
00321
00322 int
00323 initRuleStruct(int processType, rsComm_t *svrComm, char *irbSet, char *dvmSet, char *fnmSet)
00324 {
00325 int i;
00326 char r1[NAME_LEN], r2[RULE_SET_DEF_LENGTH], r3[RULE_SET_DEF_LENGTH];
00327
00328
00329 coreRuleStrct.MaxNumOfRules = 0;
00330 appRuleStrct.MaxNumOfRules = 0;
00331 GlobalAllRuleExecFlag = 0;
00332
00333 if(processType == RULE_ENGINE_INIT_CACHE) {
00334 resetMutex(NULL);
00335 }
00336
00337
00338
00339 i = readRuleStructFromFile(processType, irbSet, &coreRuleStrct);
00340 if (i < 0)
00341 return(i);
00342
00343
00344 strcpy(r2,dvmSet);
00345 coreRuleVarDef.MaxNumOfDVars = 0;
00346 appRuleVarDef.MaxNumOfDVars = 0;
00347
00348 while (strlen(r2) > 0) {
00349 i = rSplitStr(r2,r1,NAME_LEN,r3,RULE_SET_DEF_LENGTH,',');
00350 if (i == 0)
00351 i = readDVarStructFromFile(r1, &coreRuleVarDef);
00352 if (i < 0)
00353 return(i);
00354 strcpy(r2,r3);
00355 }
00356 strcpy(r2,fnmSet);
00357 coreRuleFuncMapDef.MaxNumOfFMaps = 0;
00358 appRuleFuncMapDef.MaxNumOfFMaps = 0;
00359
00360 while (strlen(r2) > 0) {
00361 i = rSplitStr(r2,r1,NAME_LEN,r3,RULE_SET_DEF_LENGTH,',');
00362 if (i == 0)
00363 i = readFuncMapStructFromFile(r1, &coreRuleFuncMapDef);
00364 if (i < 0)
00365 return(i);
00366 strcpy(r2,r3);
00367 }
00368
00369 if (getenv(RETESTFLAG) != NULL) {
00370 reTestFlag = atoi(getenv(RETESTFLAG));
00371 if (getenv(RELOOPBACKFLAG) != NULL)
00372 reLoopBackFlag = atoi(getenv(RELOOPBACKFLAG));
00373 else
00374 reLoopBackFlag = 0;
00375 }
00376 else {
00377 reTestFlag = 0;
00378 reLoopBackFlag = 0;
00379 }
00380 if (getenv("GLOBALALLRULEEXECFLAG") != NULL)
00381 GlobalAllRuleExecFlag = 9;
00382
00383 if (getenv(GLOBALREDEBUGFLAG) != NULL) {
00384 GlobalREDebugFlag = atoi(getenv(GLOBALREDEBUGFLAG));
00385 }
00386 if (getenv(GLOBALREAUDITFLAG) != NULL) {
00387 GlobalREAuditFlag = atoi(getenv(GLOBALREAUDITFLAG));
00388 }
00389 if (GlobalREAuditFlag == 0 ) {
00390 GlobalREAuditFlag = GlobalREDebugFlag;
00391 }
00392 delayStack.size = NAME_LEN;
00393 delayStack.len = 0;
00394 delayStack.value = NULL;
00395
00396 msParamStack.size = NAME_LEN;
00397 msParamStack.len = 0;
00398 msParamStack.value = NULL;
00399
00400 initializeReDebug(svrComm, GlobalREDebugFlag);
00401
00402 return(0);
00403 }
00404
00405
00406 int
00407 readRuleSetFromDB(char *ruleBaseName, char *versionStr, RuleSet *ruleSet, ruleExecInfo_t *rei, rError_t *errmsg, Region *region)
00408 {
00409 int i,status;
00410 genQueryInp_t genQueryInp;
00411 genQueryOut_t *genQueryOut = NULL;
00412 char condstr[MAX_NAME_LEN], condstr2[MAX_NAME_LEN];
00413 sqlResult_t *r[8];
00414 memset(&genQueryInp, 0, sizeof(genQueryInp));
00415 genQueryInp.maxRows = MAX_SQL_ROWS;
00416
00417 snprintf(condstr, MAX_NAME_LEN, "= '%s'", ruleBaseName);
00418 addInxVal(&genQueryInp.sqlCondInp, COL_RULE_BASE_MAP_BASE_NAME, condstr);
00419 snprintf(condstr2, MAX_NAME_LEN, "= '%s'", versionStr);
00420 addInxVal(&genQueryInp.sqlCondInp, COL_RULE_BASE_MAP_VERSION, condstr2);
00421
00422 addInxIval(&genQueryInp.selectInp, COL_RULE_BASE_MAP_PRIORITY, ORDER_BY);
00423 addInxIval(&genQueryInp.selectInp, COL_RULE_BASE_MAP_BASE_NAME, 1);
00424 addInxIval(&genQueryInp.selectInp, COL_RULE_NAME, 1);
00425 addInxIval(&genQueryInp.selectInp, COL_RULE_EVENT, 1);
00426 addInxIval(&genQueryInp.selectInp, COL_RULE_CONDITION, 1);
00427 addInxIval(&genQueryInp.selectInp, COL_RULE_BODY, 1);
00428 addInxIval(&genQueryInp.selectInp, COL_RULE_RECOVERY, 1);
00429 addInxIval(&genQueryInp.selectInp, COL_RULE_ID, 1);
00430 Env *env = newEnv(newHashTable2(100, region), NULL, NULL, region);
00431 status = rsGenQuery(rei->rsComm, &genQueryInp, &genQueryOut);
00432 while ( status >= 0 && genQueryOut->rowCnt > 0 ) {
00433 r[0] = getSqlResultByInx (genQueryOut, COL_RULE_BASE_MAP_BASE_NAME);
00434 r[1] = getSqlResultByInx (genQueryOut, COL_RULE_NAME);
00435 r[2] = getSqlResultByInx (genQueryOut, COL_RULE_EVENT);
00436 r[3] = getSqlResultByInx (genQueryOut, COL_RULE_CONDITION);
00437 r[4] = getSqlResultByInx (genQueryOut, COL_RULE_BODY);
00438 r[5] = getSqlResultByInx (genQueryOut, COL_RULE_RECOVERY);
00439 r[6] = getSqlResultByInx (genQueryOut, COL_RULE_ID);
00440 for (i = 0; i<genQueryOut->rowCnt; i++) {
00441 char ruleStr[MAX_RULE_LEN * 4];
00442
00443
00444 char *ruleHead = strdup(&r[2]->value[r[2]->len * i]);
00445 char *ruleCondition = strdup(&r[3]->value[r[3]->len * i]);
00446 char *ruleAction = strdup(&r[4]->value[r[4]->len * i]);
00447 char *ruleRecovery = strdup(&r[5]->value[r[5]->len * i]);
00448 long ruleId = atol(&r[6]->value[r[6]->len * i]);
00449 if(ruleRecovery[0] == '@') {
00450
00451 if(strcmp(ruleRecovery+1, "DATA") == 0) {
00452 snprintf(ruleStr, MAX_RULE_LEN * 4, "data %s", ruleHead);
00453 } else if(strcmp(ruleRecovery+1, "CONSTR") == 0) {
00454 snprintf(ruleStr, MAX_RULE_LEN * 4, "constructor %s : %s", ruleHead, ruleAction);
00455 } else if(strcmp(ruleRecovery+1, "EXTERN") == 0) {
00456 snprintf(ruleStr, MAX_RULE_LEN * 4, "%s : %s", ruleHead, ruleAction);
00457 } else if(strcmp(ruleRecovery+1, "FUNC") == 0) {
00458 snprintf(ruleStr, MAX_RULE_LEN * 4, "%s = %s\n @(\"id\", \"%ld\")", ruleHead, ruleAction, ruleId);
00459 } else {
00460 snprintf(ruleStr, MAX_RULE_LEN * 4, "%s { on %s %s @(\"id\", \"%ld\") }\n", ruleHead, ruleCondition, ruleAction, ruleId);
00461 }
00462 } else {
00463 snprintf(ruleStr, MAX_RULE_LEN * 4, "%s|%s|%s|%s", ruleHead, ruleCondition, ruleAction, ruleRecovery);
00464 }
00465 Pointer *p = newPointer2(ruleStr);
00466 int errloc;
00467 int errcode = parseRuleSet(p, ruleSet, env, &errloc, errmsg, region);
00468 deletePointer(p);
00469 if(errcode<0) {
00470
00471 freeGenQueryOut (&genQueryOut);
00472 free( ruleHead );
00473 free( ruleCondition );
00474 free( ruleAction );
00475 free( ruleRecovery );
00476 return errcode;
00477 }
00478
00479 free( ruleHead );
00480 free( ruleCondition );
00481 free( ruleAction );
00482 free( ruleRecovery );
00483
00484 }
00485 genQueryInp.continueInx = genQueryOut->continueInx;
00486 freeGenQueryOut (&genQueryOut);
00487 if (genQueryInp.continueInx > 0) {
00488
00489 status = rsGenQuery (rei->rsComm, &genQueryInp, &genQueryOut);
00490 }
00491 else
00492 break;
00493 }
00494
00495 return(0);
00496 }
00497
00498 int
00499 readRuleStructFromDB(char *ruleBaseName, char *versionStr, ruleStruct_t *inRuleStrct, ruleExecInfo_t *rei)
00500 {
00501 int i,l,status;
00502 genQueryInp_t genQueryInp;
00503 genQueryOut_t *genQueryOut = NULL;
00504 char condstr[MAX_NAME_LEN], condstr2[MAX_NAME_LEN];
00505 sqlResult_t *r[8];
00506 memset(&genQueryInp, 0, sizeof(genQueryInp));
00507 genQueryInp.maxRows = MAX_SQL_ROWS;
00508
00509 snprintf(condstr, MAX_NAME_LEN, "= '%s'", ruleBaseName);
00510 addInxVal(&genQueryInp.sqlCondInp, COL_RULE_BASE_MAP_BASE_NAME, condstr);
00511 snprintf(condstr2, MAX_NAME_LEN, "= '%s'", versionStr);
00512 addInxVal(&genQueryInp.sqlCondInp, COL_RULE_BASE_MAP_VERSION, condstr2);
00513
00514 addInxIval(&genQueryInp.selectInp, COL_RULE_BASE_MAP_PRIORITY, ORDER_BY);
00515 addInxIval(&genQueryInp.selectInp, COL_RULE_BASE_MAP_BASE_NAME, 1);
00516 addInxIval(&genQueryInp.selectInp, COL_RULE_NAME, 1);
00517 addInxIval(&genQueryInp.selectInp, COL_RULE_EVENT, 1);
00518 addInxIval(&genQueryInp.selectInp, COL_RULE_CONDITION, 1);
00519 addInxIval(&genQueryInp.selectInp, COL_RULE_BODY, 1);
00520 addInxIval(&genQueryInp.selectInp, COL_RULE_RECOVERY, 1);
00521 addInxIval(&genQueryInp.selectInp, COL_RULE_ID, 1);
00522 l = inRuleStrct->MaxNumOfRules;
00523 status = rsGenQuery(rei->rsComm, &genQueryInp, &genQueryOut);
00524 while ( status >= 0 && genQueryOut->rowCnt > 0 ) {
00525 r[0] = getSqlResultByInx (genQueryOut, COL_RULE_BASE_MAP_BASE_NAME);
00526 r[1] = getSqlResultByInx (genQueryOut, COL_RULE_NAME);
00527 r[2] = getSqlResultByInx (genQueryOut, COL_RULE_EVENT);
00528 r[3] = getSqlResultByInx (genQueryOut, COL_RULE_CONDITION);
00529 r[4] = getSqlResultByInx (genQueryOut, COL_RULE_BODY);
00530 r[5] = getSqlResultByInx (genQueryOut, COL_RULE_RECOVERY);
00531 r[6] = getSqlResultByInx (genQueryOut, COL_RULE_ID);
00532 for (i = 0; i<genQueryOut->rowCnt; i++) {
00533 inRuleStrct->ruleBase[l] = strdup(&r[0]->value[r[0]->len * i]);
00534 inRuleStrct->action[l] = strdup(&r[1]->value[r[1]->len * i]);
00535 inRuleStrct->ruleHead[l] = strdup(&r[2]->value[r[2]->len * i]);
00536 inRuleStrct->ruleCondition[l] = strdup(&r[3]->value[r[3]->len * i]);
00537 inRuleStrct->ruleAction[l] = strdup(&r[4]->value[r[4]->len * i]);
00538 inRuleStrct->ruleRecovery[l] = strdup(&r[5]->value[r[5]->len * i]);
00539 inRuleStrct->ruleId[l] = atol(&r[6]->value[r[6]->len * i]);
00540 l++;
00541 }
00542 genQueryInp.continueInx = genQueryOut->continueInx;
00543 freeGenQueryOut (&genQueryOut);
00544 if (genQueryInp.continueInx > 0) {
00545
00546 status = rsGenQuery (rei->rsComm, &genQueryInp, &genQueryOut);
00547 }
00548 else
00549 break;
00550 }
00551 inRuleStrct->MaxNumOfRules = l;
00552 return(0);
00553 }
00554
00555
00556 int
00557 readDVMapStructFromDB(char *dvmBaseName, char *versionStr, rulevardef_t *inDvmStrct, ruleExecInfo_t *rei)
00558 {
00559 int i,l,status;
00560 genQueryInp_t genQueryInp;
00561 genQueryOut_t *genQueryOut = NULL;
00562 char condstr[MAX_NAME_LEN], condstr2[MAX_NAME_LEN];
00563 sqlResult_t *r[5];
00564 memset(&genQueryInp, 0, sizeof(genQueryInp));
00565 genQueryInp.maxRows = MAX_SQL_ROWS;
00566
00567 snprintf(condstr, MAX_NAME_LEN, "= '%s'", dvmBaseName);
00568 addInxVal(&genQueryInp.sqlCondInp, COL_DVM_BASE_MAP_BASE_NAME, condstr);
00569 snprintf(condstr2, MAX_NAME_LEN, "= '%s'", versionStr);
00570 addInxVal(&genQueryInp.sqlCondInp, COL_DVM_BASE_MAP_VERSION, condstr2);
00571
00572 addInxIval(&genQueryInp.selectInp, COL_DVM_EXT_VAR_NAME, 1);
00573 addInxIval(&genQueryInp.selectInp, COL_DVM_CONDITION, 1);
00574 addInxIval(&genQueryInp.selectInp, COL_DVM_INT_MAP_PATH, 1);
00575 addInxIval(&genQueryInp.selectInp, COL_DVM_ID, ORDER_BY);
00576 l = inDvmStrct->MaxNumOfDVars;
00577 status = rsGenQuery(rei->rsComm, &genQueryInp, &genQueryOut);
00578 while ( status >= 0 && genQueryOut->rowCnt > 0 ) {
00579 r[0] = getSqlResultByInx (genQueryOut, COL_DVM_EXT_VAR_NAME);
00580 r[1] = getSqlResultByInx (genQueryOut, COL_DVM_CONDITION);
00581 r[2] = getSqlResultByInx (genQueryOut, COL_DVM_INT_MAP_PATH);
00582 r[3] = getSqlResultByInx (genQueryOut, COL_DVM_ID);
00583 for (i = 0; i<genQueryOut->rowCnt; i++) {
00584 inDvmStrct->varName[l] = strdup(&r[0]->value[r[0]->len * i]);
00585 inDvmStrct->action[l] = strdup(&r[1]->value[r[1]->len * i]);
00586 inDvmStrct->var2CMap[l] = strdup(&r[2]->value[r[2]->len * i]);
00587 inDvmStrct->varId[l] = atol(&r[3]->value[r[3]->len * i]);
00588 l++;
00589 }
00590 genQueryInp.continueInx = genQueryOut->continueInx;
00591 freeGenQueryOut (&genQueryOut);
00592 if (genQueryInp.continueInx > 0) {
00593
00594 status = rsGenQuery (rei->rsComm, &genQueryInp, &genQueryOut);
00595 }
00596 else
00597 break;
00598 }
00599 inDvmStrct->MaxNumOfDVars = l;
00600 return(0);
00601 }
00602
00603
00604
00605 int
00606 readFNMapStructFromDB(char *fnmBaseName, char *versionStr, fnmapStruct_t *inFnmStrct, ruleExecInfo_t *rei)
00607 {
00608 int i,l,status;
00609 genQueryInp_t genQueryInp;
00610 genQueryOut_t *genQueryOut = NULL;
00611 char condstr[MAX_NAME_LEN], condstr2[MAX_NAME_LEN];
00612 sqlResult_t *r[5];
00613 memset(&genQueryInp, 0, sizeof(genQueryInp));
00614 genQueryInp.maxRows = MAX_SQL_ROWS;
00615
00616 snprintf(condstr, MAX_NAME_LEN, "= '%s'", fnmBaseName);
00617 addInxVal(&genQueryInp.sqlCondInp, COL_FNM_BASE_MAP_BASE_NAME, condstr);
00618 snprintf(condstr2, MAX_NAME_LEN, "= '%s'", versionStr);
00619 addInxVal(&genQueryInp.sqlCondInp, COL_FNM_BASE_MAP_VERSION, condstr2);
00620
00621 addInxIval(&genQueryInp.selectInp, COL_FNM_EXT_FUNC_NAME, 1);
00622 addInxIval(&genQueryInp.selectInp, COL_FNM_INT_FUNC_NAME, 1);
00623 addInxIval(&genQueryInp.selectInp, COL_FNM_ID, ORDER_BY);
00624
00625 l = inFnmStrct->MaxNumOfFMaps;
00626 status = rsGenQuery(rei->rsComm, &genQueryInp, &genQueryOut);
00627 while ( status >= 0 && genQueryOut->rowCnt > 0 ) {
00628 r[0] = getSqlResultByInx (genQueryOut, COL_FNM_EXT_FUNC_NAME);
00629 r[1] = getSqlResultByInx (genQueryOut, COL_FNM_INT_FUNC_NAME);
00630 r[2] = getSqlResultByInx (genQueryOut, COL_FNM_ID);
00631 for (i = 0; i<genQueryOut->rowCnt; i++) {
00632 inFnmStrct->funcName[l] = strdup(&r[0]->value[r[0]->len * i]);
00633 inFnmStrct->func2CMap[l] = strdup(&r[1]->value[r[1]->len * i]);
00634 inFnmStrct->fmapId[l] = atol(&r[2]->value[r[2]->len * i]);
00635 l++;
00636 }
00637 genQueryInp.continueInx = genQueryOut->continueInx;
00638 freeGenQueryOut (&genQueryOut);
00639 if (genQueryInp.continueInx > 0) {
00640
00641 status = rsGenQuery (rei->rsComm, &genQueryInp, &genQueryOut);
00642 }
00643 else
00644 break;
00645 }
00646 inFnmStrct->MaxNumOfFMaps = l;
00647 return(0);
00648 }
00649
00650
00651
00652 int
00653 readMsrvcStructFromDB(int inStatus, msrvcStruct_t *inMsrvcStrct, ruleExecInfo_t *rei)
00654 {
00655 int i,l,status;
00656 genQueryInp_t genQueryInp;
00657 genQueryOut_t *genQueryOut = NULL;
00658 sqlResult_t *r[10];
00659 memset(&genQueryInp, 0, sizeof(genQueryInp));
00660 genQueryInp.maxRows = MAX_SQL_ROWS;
00661 char condstr[MAX_NAME_LEN];
00662
00663 snprintf(condstr, MAX_NAME_LEN, "= '%i'", inStatus);
00664 addInxVal(&genQueryInp.sqlCondInp, COL_MSRVC_STATUS, condstr);
00665
00666 addInxIval(&genQueryInp.selectInp, COL_MSRVC_NAME, 1);
00667 addInxIval(&genQueryInp.selectInp, COL_MSRVC_MODULE_NAME, 1);
00668 addInxIval(&genQueryInp.selectInp, COL_MSRVC_SIGNATURE, 1);
00669 addInxIval(&genQueryInp.selectInp, COL_MSRVC_VERSION, 1);
00670 addInxIval(&genQueryInp.selectInp, COL_MSRVC_HOST, 1);
00671 addInxIval(&genQueryInp.selectInp, COL_MSRVC_LOCATION, 1);
00672 addInxIval(&genQueryInp.selectInp, COL_MSRVC_LANGUAGE, 1);
00673 addInxIval(&genQueryInp.selectInp, COL_MSRVC_TYPE_NAME, 1);
00674 addInxIval(&genQueryInp.selectInp, COL_MSRVC_STATUS, 1);
00675 addInxIval(&genQueryInp.selectInp, COL_MSRVC_ID, ORDER_BY);
00676
00677 l = inMsrvcStrct->MaxNumOfMsrvcs;
00678 status = rsGenQuery(rei->rsComm, &genQueryInp, &genQueryOut);
00679 while ( status >= 0 && genQueryOut->rowCnt > 0 ) {
00680 r[0] = getSqlResultByInx (genQueryOut, COL_MSRVC_MODULE_NAME);
00681 r[1] = getSqlResultByInx (genQueryOut, COL_MSRVC_NAME);
00682 r[2] = getSqlResultByInx (genQueryOut, COL_MSRVC_SIGNATURE);
00683 r[3] = getSqlResultByInx (genQueryOut, COL_MSRVC_VERSION);
00684 r[4] = getSqlResultByInx (genQueryOut, COL_MSRVC_HOST);
00685 r[5] = getSqlResultByInx (genQueryOut, COL_MSRVC_LOCATION);
00686 r[6] = getSqlResultByInx (genQueryOut, COL_MSRVC_LANGUAGE);
00687 r[7] = getSqlResultByInx (genQueryOut, COL_MSRVC_TYPE_NAME);
00688 r[8] = getSqlResultByInx (genQueryOut, COL_MSRVC_STATUS);
00689 r[9] = getSqlResultByInx (genQueryOut, COL_MSRVC_ID);
00690 for (i = 0; i<genQueryOut->rowCnt; i++) {
00691 inMsrvcStrct->moduleName[l] = strdup(&r[0]->value[r[0]->len * i]);
00692 inMsrvcStrct->msrvcName[l] = strdup(&r[1]->value[r[1]->len * i]);
00693 inMsrvcStrct->msrvcSignature[l] = strdup(&r[2]->value[r[2]->len * i]);
00694 inMsrvcStrct->msrvcVersion[l] = strdup(&r[3]->value[r[3]->len * i]);
00695 inMsrvcStrct->msrvcHost[l] = strdup(&r[4]->value[r[4]->len * i]);
00696 inMsrvcStrct->msrvcLocation[l] = strdup(&r[5]->value[r[5]->len * i]);
00697 inMsrvcStrct->msrvcLanguage[l] = strdup(&r[6]->value[r[6]->len * i]);
00698 inMsrvcStrct->msrvcTypeName[l] = strdup(&r[7]->value[r[7]->len * i]);
00699 inMsrvcStrct->msrvcStatus[l] = atol(&r[8]->value[r[8]->len * i]);
00700 inMsrvcStrct->msrvcId[l] = atol(&r[9]->value[r[9]->len * i]);
00701 l++;
00702 }
00703 genQueryInp.continueInx = genQueryOut->continueInx;
00704 freeGenQueryOut (&genQueryOut);
00705 if (genQueryInp.continueInx > 0) {
00706
00707 status = rsGenQuery (rei->rsComm, &genQueryInp, &genQueryOut);
00708 }
00709 else
00710 break;
00711 }
00712 inMsrvcStrct->MaxNumOfMsrvcs = l;
00713 return(0);
00714 }
00715
00716 int
00717 readRuleStructFromFile(int processType, char *ruleBaseName, ruleStruct_t *inRuleStrct)
00718 {
00719
00720 return loadRuleFromCacheOrFile(processType, ruleBaseName, inRuleStrct);
00721 }
00722
00723 int
00724 clearRuleStruct(ruleStruct_t *inRuleStrct)
00725 {
00726 int i;
00727 for (i = 0 ; i < inRuleStrct->MaxNumOfRules ; i++) {
00728 if (inRuleStrct->ruleBase[i] != NULL)
00729 free(inRuleStrct->ruleBase[i]);
00730 if (inRuleStrct->ruleHead[i] != NULL)
00731 free(inRuleStrct->ruleHead[i]);
00732 if (inRuleStrct->ruleCondition[i] != NULL)
00733 free(inRuleStrct->ruleCondition[i]);
00734 if (inRuleStrct->ruleAction[i] != NULL)
00735 free(inRuleStrct->ruleAction[i]);
00736 if (inRuleStrct->ruleRecovery[i] != NULL)
00737 free(inRuleStrct->ruleRecovery[i]);
00738
00739 }
00740 inRuleStrct->MaxNumOfRules = 0;
00741 if(inRuleStrct == &coreRuleStrct) {
00742 clearResources(RESC_CORE_RULE_SET | RESC_CORE_FUNC_DESC_INDEX);
00743 } else if(inRuleStrct == &appRuleStrct) {
00744 clearResources(RESC_APP_RULE_SET | RESC_APP_FUNC_DESC_INDEX);
00745 }
00746
00747 return(0);
00748 }
00749
00750 int clearDVarStruct(rulevardef_t *inRuleVarDef)
00751 {
00752 int i;
00753 for (i = 0 ; i < inRuleVarDef->MaxNumOfDVars; i++) {
00754 if (inRuleVarDef->varName[i] != NULL)
00755 free(inRuleVarDef->varName[i]);
00756 if (inRuleVarDef->action[i] != NULL)
00757 free(inRuleVarDef->action[i]);
00758 if (inRuleVarDef->var2CMap[i] != NULL)
00759 free(inRuleVarDef->var2CMap[i]);
00760 }
00761 inRuleVarDef->MaxNumOfDVars = 0;
00762 return(0);
00763 }
00764
00765 int clearFuncMapStruct( rulefmapdef_t* inRuleFuncMapDef)
00766 {
00767 int i;
00768 for (i = 0 ; i < inRuleFuncMapDef->MaxNumOfFMaps; i++) {
00769 if (inRuleFuncMapDef->funcName[i] != NULL)
00770 free(inRuleFuncMapDef->funcName[i]);
00771 if (inRuleFuncMapDef->func2CMap[i] != NULL)
00772 free(inRuleFuncMapDef->func2CMap[i]);
00773 }
00774 inRuleFuncMapDef->MaxNumOfFMaps = 0;
00775 if(inRuleFuncMapDef == &coreRuleFuncMapDef) {
00776 clearIndex(&coreRuleFuncMapDefIndex);
00777 } else if(inRuleFuncMapDef == &appRuleFuncMapDef) {
00778 clearIndex(&appRuleFuncMapDefIndex);
00779 }
00780
00781 return(0);
00782 }
00783
00784
00785 int
00786 readDVarStructFromFile(char *dvarBaseName,rulevardef_t *inRuleVarDef)
00787 {
00788 int i = 0;
00789 char l0[MAX_DVAR_LENGTH];
00790 char l1[MAX_DVAR_LENGTH];
00791 char l2[MAX_DVAR_LENGTH];
00792 char l3[MAX_DVAR_LENGTH];
00793 char dvarsFileName[MAX_NAME_LEN];
00794 FILE *file;
00795 char buf[MAX_DVAR_LENGTH];
00796 char *configDir;
00797
00798 i = inRuleVarDef->MaxNumOfDVars;
00799
00800 if (dvarBaseName[0] == '/' || dvarBaseName[0] == '\\' ||
00801 dvarBaseName[1] == ':') {
00802 snprintf (dvarsFileName,MAX_NAME_LEN, "%s",dvarBaseName);
00803 }
00804 else {
00805 configDir = getConfigDir ();
00806 snprintf (dvarsFileName,MAX_NAME_LEN, "%s/reConfigs/%s.dvm", configDir,dvarBaseName);
00807 }
00808
00809 file = fopen(dvarsFileName, "r");
00810 if (file == NULL) {
00811 rodsLog(LOG_NOTICE,
00812 "readDvarStructFromFile() could not open dvm file %s\n",
00813 dvarsFileName);
00814 return(DVARMAP_FILE_READ_ERROR);
00815 }
00816 buf[MAX_DVAR_LENGTH-1]='\0';
00817 while (fgets (buf, MAX_DVAR_LENGTH-1, file) != NULL) {
00818 if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = '\0';
00819 if (buf[0] == '#' || strlen(buf) < 4)
00820 continue;
00821 rSplitStr(buf, l1, MAX_DVAR_LENGTH, l0, MAX_DVAR_LENGTH, '|');
00822 inRuleVarDef->varName[i] = strdup(l1);
00823
00824 rSplitStr(l0, l1, MAX_DVAR_LENGTH, l3, MAX_DVAR_LENGTH,'|');
00825 inRuleVarDef->action[i] = strdup(l1);
00826 rSplitStr(l3, l1, MAX_DVAR_LENGTH, l2, MAX_DVAR_LENGTH,'|');
00827 inRuleVarDef->var2CMap[i] = strdup(l1);
00828
00829 if (strlen(l2) > 0)
00830 inRuleVarDef->varId[i] = atoll(l2);
00831 else
00832 inRuleVarDef->varId[i] = i;
00833 i++;
00834 }
00835 fclose (file);
00836 inRuleVarDef->MaxNumOfDVars = (long int) i;
00837 return(0);
00838 }
00839
00840 int
00841 readFuncMapStructFromFile(char *fmapBaseName, rulefmapdef_t* inRuleFuncMapDef)
00842 {
00843 int i = 0;
00844 char l0[MAX_FMAP_LENGTH];
00845 char l1[MAX_FMAP_LENGTH];
00846 char l2[MAX_FMAP_LENGTH];
00847
00848 char fmapsFileName[MAX_NAME_LEN];
00849 FILE *file;
00850 char buf[MAX_FMAP_LENGTH];
00851 char *configDir;
00852
00853 i = inRuleFuncMapDef->MaxNumOfFMaps;
00854
00855 if (fmapBaseName[0] == '/' || fmapBaseName[0] == '\\' ||
00856 fmapBaseName[1] == ':') {
00857 snprintf (fmapsFileName,MAX_NAME_LEN, "%s",fmapBaseName);
00858 }
00859 else {
00860 configDir = getConfigDir ();
00861 snprintf (fmapsFileName,MAX_NAME_LEN, "%s/reConfigs/%s.fnm", configDir,fmapBaseName);
00862 }
00863 file = fopen(fmapsFileName, "r");
00864 if (file == NULL) {
00865 rodsLog(LOG_NOTICE,
00866 "readFmapStructFromFile() could not open fnm file %s\n",
00867 fmapsFileName);
00868 return(FMAP_FILE_READ_ERROR);
00869 }
00870 buf[MAX_FMAP_LENGTH-1]='\0';
00871 while (fgets (buf, MAX_FMAP_LENGTH-1, file) != NULL) {
00872 if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = '\0';
00873 if (buf[0] == '#' || strlen(buf) < 4)
00874 continue;
00875 rSplitStr(buf, l1, MAX_FMAP_LENGTH, l0, MAX_FMAP_LENGTH, '|');
00876 inRuleFuncMapDef->funcName[i] = strdup(l1);
00877 rSplitStr(l0,l1, MAX_FMAP_LENGTH, l2, MAX_FMAP_LENGTH,'|');
00878 inRuleFuncMapDef->func2CMap[i] = strdup(l1);
00879 if (strlen(l2) > 0)
00880 inRuleFuncMapDef->fmapId[i] = atoll(l2);
00881 else
00882 inRuleFuncMapDef->fmapId[i] = i;
00883 i++;
00884 }
00885 fclose (file);
00886 inRuleFuncMapDef->MaxNumOfFMaps = (long int) i;
00887 if(inRuleFuncMapDef == &coreRuleFuncMapDef) {
00888 createFuncMapDefIndex(&coreRuleFuncMapDef, &coreRuleFuncMapDefIndex);
00889 } else if(inRuleFuncMapDef == &appRuleFuncMapDef) {
00890 createFuncMapDefIndex(&appRuleFuncMapDef, &appRuleFuncMapDefIndex);
00891 }
00892 return(0);
00893 }
00894
00895 int
00896 readMsrvcStructFromFile(char *msrvcFileName, msrvcStruct_t* inMsrvcStruct)
00897 {
00898 int i = 0;
00899 char l0[MAX_RULE_LENGTH];
00900 char l1[MAX_RULE_LENGTH];
00901 char l2[MAX_RULE_LENGTH];
00902 char mymsrvcFileName[MAX_NAME_LEN];
00903 FILE *file;
00904 char buf[MAX_RULE_LENGTH];
00905 char *configDir;
00906
00907
00908 i = inMsrvcStruct->MaxNumOfMsrvcs;
00909
00910 if (msrvcFileName[0] == '/' || msrvcFileName[0] == '\\' ||
00911 msrvcFileName[1] == ':') {
00912 snprintf (mymsrvcFileName,MAX_NAME_LEN, "%s",msrvcFileName);
00913 }
00914 else {
00915 configDir = getConfigDir ();
00916 snprintf (mymsrvcFileName,MAX_NAME_LEN, "%s/reConfigs/%s.msi", configDir,msrvcFileName);
00917 }
00918 file = fopen(mymsrvcFileName, "r");
00919 if (file == NULL) {
00920 rodsLog(LOG_NOTICE,
00921 "readMservcStructFromFile() could not open msrvc file %s\n",
00922 mymsrvcFileName);
00923 return(MSRVC_FILE_READ_ERROR);
00924 }
00925 buf[MAX_RULE_LENGTH-1]='\0';
00926 while (fgets (buf, MAX_RULE_LENGTH-1, file) != NULL) {
00927 if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = '\0';
00928 if (buf[0] == '#' || strlen(buf) < 4)
00929 continue;
00930 rSplitStr(buf, l1, MAX_RULE_LENGTH, l0, MAX_RULE_LENGTH, '|');
00931 inMsrvcStruct->moduleName[i] = strdup(l1);
00932
00933 rSplitStr(l0, l1, MAX_RULE_LENGTH, l2, MAX_RULE_LENGTH,'|');
00934 inMsrvcStruct->msrvcName[i] = strdup(l1);
00935 rSplitStr(l2, l1, MAX_RULE_LENGTH, l0, MAX_RULE_LENGTH, '|');
00936 inMsrvcStruct->msrvcSignature[i] = strdup(l1);
00937
00938 rSplitStr(l0, l1, MAX_RULE_LENGTH, l2, MAX_RULE_LENGTH,'|');
00939 inMsrvcStruct->msrvcVersion[i] = strdup(l1);
00940 rSplitStr(l2, l1, MAX_RULE_LENGTH, l0, MAX_RULE_LENGTH, '|');
00941 inMsrvcStruct->msrvcHost[i] = strdup(l1);
00942
00943 rSplitStr(l0, l1, MAX_RULE_LENGTH, l2, MAX_RULE_LENGTH,'|');
00944 inMsrvcStruct->msrvcLocation[i] = strdup(l1);
00945 rSplitStr(l2, l1, MAX_RULE_LENGTH, l0, MAX_RULE_LENGTH, '|');
00946 inMsrvcStruct->msrvcLanguage[i] = strdup(l1);
00947
00948 rSplitStr(l0, l1, MAX_RULE_LENGTH, l2, MAX_RULE_LENGTH,'|');
00949 inMsrvcStruct->msrvcTypeName[i] = strdup(l1);
00950 rSplitStr(l2, l1, MAX_RULE_LENGTH, l0, MAX_RULE_LENGTH, '|');
00951 inMsrvcStruct->msrvcStatus[i] = atol(l1);
00952 if (strlen(l0) > 0)
00953 inMsrvcStruct->msrvcId[i] = atol(l1);
00954 else
00955 inMsrvcStruct->msrvcId[i] = (long int) i;
00956 i++;
00957 }
00958 fclose (file);
00959 inMsrvcStruct->MaxNumOfMsrvcs = i;
00960 return(0);
00961 }
00962
00963 int
00964 findNextRule (char *action, int *ruleInx)
00965 {
00966 int i;
00967 i = *ruleInx;
00968 i++;
00969
00970 if (i < 0)
00971 i = 0;
00972 if (i < APP_RULE_INDEX_OFF) {
00973 for( ; i < appRuleStrct.MaxNumOfRules; i++) {
00974 if (!strcmp( appRuleStrct.action[i],action)) {
00975 *ruleInx = i;
00976 return(0);
00977 }
00978 }
00979 i = APP_RULE_INDEX_OFF;
00980 }
00981 i = i - APP_RULE_INDEX_OFF;
00982 if (i < CORE_RULE_INDEX_OFF) {
00983 for( ; i < appRuleStrct.MaxNumOfRules; i++) {
00984 if (!strcmp( appRuleStrct.action[i],action)) {
00985 *ruleInx = i;
00986 return(0);
00987 }
00988 }
00989 i = CORE_RULE_INDEX_OFF;
00990 }
00991 i = i - CORE_RULE_INDEX_OFF;
00992 for( ; i < coreRuleStrct.MaxNumOfRules; i++) {
00993 if (!strcmp( coreRuleStrct.action[i],action)) {
00994 *ruleInx = i + APP_RULE_INDEX_OFF;
00995 return(0);
00996 }
00997 }
00998 return(NO_MORE_RULES_ERR);
00999 }
01000
01001
01002
01003 int
01004 getRule(int ri, char *ruleBase, char *ruleHead, char *ruleCondition,
01005 char *ruleAction, char *ruleRecovery, int rSize)
01006 {
01007
01008 if (ri < CORE_RULE_INDEX_OFF) {
01009 rstrcpy( ruleBase , appRuleStrct.ruleBase[ri], rSize);
01010 rstrcpy( ruleHead , appRuleStrct.ruleHead[ri], rSize);
01011 rstrcpy( ruleCondition , appRuleStrct.ruleCondition[ri], rSize);
01012 rstrcpy( ruleAction , appRuleStrct.ruleAction[ri], rSize);
01013 rstrcpy( ruleRecovery , appRuleStrct.ruleRecovery[ri], rSize);
01014 }
01015 else {
01016 ri = ri - CORE_RULE_INDEX_OFF;
01017 rstrcpy( ruleBase , coreRuleStrct.ruleBase[ri], rSize);
01018 rstrcpy( ruleHead , coreRuleStrct.ruleHead[ri], rSize);
01019 rstrcpy( ruleCondition , coreRuleStrct.ruleCondition[ri], rSize);
01020 rstrcpy( ruleAction , coreRuleStrct.ruleAction[ri], rSize);
01021 rstrcpy( ruleRecovery , coreRuleStrct.ruleRecovery[ri], rSize);
01022 }
01023 return(0);
01024 }
01025
01026 int
01027 insertRulesIntoDBNew(char * baseName, RuleSet *ruleSet,
01028 ruleExecInfo_t *rei)
01029 {
01030 generalRowInsertInp_t generalRowInsertInp;
01031 char ruleIdStr[MAX_NAME_LEN];
01032 int rc1, i;
01033 int mapPriorityInt = 1;
01034 char mapPriorityStr[50];
01035 endTransactionInp_t endTransactionInp;
01036 char myTime[50];
01037
01038 memset (&endTransactionInp, 0, sizeof (endTransactionInp_t));
01039 getNowStr(myTime);
01040
01041
01042 generalRowInsertInp.tableName = "versionRuleBase";
01043 generalRowInsertInp.arg1 = baseName;
01044 generalRowInsertInp.arg2 = myTime;
01045
01046 rc1 = rsGeneralRowInsert(rei->rsComm, &generalRowInsertInp);
01047 if (rc1 < 0) {
01048 endTransactionInp.arg0 = "rollback";
01049 rsEndTransaction(rei->rsComm, &endTransactionInp);
01050 return(rc1);
01051 }
01052
01053 for (i = 0; i < ruleSet->len; i++) {
01054 RuleDesc *rd = ruleSet->rules[i];
01055 char *ruleType;
01056 Node *ruleNode = rd->node;
01057 char ruleNameStr[MAX_RULE_LEN];
01058 char ruleCondStr[MAX_RULE_LEN];
01059 char ruleActionRecoveryStr[MAX_RULE_LEN];
01060 Node *avu;
01061 int s;
01062 char *p;
01063 switch(rd->ruleType) {
01064 case RK_FUNC:
01065 ruleType = "@FUNC";
01066 p = ruleNameStr;
01067 s = MAX_RULE_LEN;
01068 ruleNameToString(&p, &s, 0, ruleNode->subtrees[0]);
01069 p = ruleCondStr;
01070 s = MAX_RULE_LEN;
01071 termToString(&p, &s, 0, MIN_PREC, ruleNode->subtrees[1], 0 );
01072 p = ruleActionRecoveryStr;
01073 s = MAX_RULE_LEN;
01074 termToString(&p, &s, 0, MIN_PREC, ruleNode->subtrees[2], 0 );
01075 avu = lookupAVUFromMetadata(ruleNode->subtrees[4], "id");
01076 if(avu!=NULL) {
01077 rstrcpy(ruleIdStr, avu->subtrees[1]->text, MAX_NAME_LEN);
01078 } else {
01079 rstrcpy(ruleIdStr, "", MAX_NAME_LEN);
01080 }
01081 break;
01082 case RK_REL:
01083 ruleType = "@REL";
01084 p = ruleNameStr;
01085 s = MAX_RULE_LEN;
01086 ruleNameToString(&p, &s, 0, ruleNode->subtrees[0]);
01087 p = ruleCondStr;
01088 s = MAX_RULE_LEN;
01089 termToString(&p, &s, 0, MIN_PREC, ruleNode->subtrees[1], 0 );
01090 p = ruleActionRecoveryStr;
01091 s = MAX_RULE_LEN;
01092 actionsToString(&p, &s, 0, ruleNode->subtrees[2], ruleNode->subtrees[3]);
01093 avu = lookupAVUFromMetadata(ruleNode->subtrees[4], "id");
01094 if(avu!=NULL) {
01095 rstrcpy(ruleIdStr, avu->subtrees[1]->text, MAX_NAME_LEN);
01096 } else {
01097 rstrcpy(ruleIdStr, "", MAX_NAME_LEN);
01098 }
01099 break;
01100 case RK_DATA:
01101 ruleType = "@DATA";
01102 p = ruleNameStr;
01103 s = MAX_RULE_LEN;
01104 ruleNameToString(&p, &s, 0, ruleNode->subtrees[0]);
01105 rstrcpy(ruleCondStr, "", MAX_RULE_LEN);
01106 rstrcpy(ruleActionRecoveryStr, "", MAX_RULE_LEN);
01107 rstrcpy(ruleIdStr, "", MAX_NAME_LEN);
01108 break;
01109 case RK_CONSTRUCTOR:
01110 ruleType = "@CONSTR";
01111 rstrcpy(ruleNameStr, ruleNode->subtrees[0]->text, MAX_RULE_LEN);
01112 rstrcpy(ruleCondStr, "", MAX_RULE_LEN);
01113 p = ruleActionRecoveryStr;
01114 s = MAX_RULE_LEN;
01115 typeToStringParser(&p, &s, 0, 0, ruleNode->subtrees[1]);
01116 rstrcpy(ruleIdStr, "", MAX_NAME_LEN);
01117 break;
01118 case RK_EXTERN:
01119 ruleType = "@EXTERN";
01120 rstrcpy(ruleNameStr, ruleNode->subtrees[0]->text, MAX_RULE_LEN);
01121 rstrcpy(ruleCondStr, "", MAX_RULE_LEN);
01122 p = ruleActionRecoveryStr;
01123 s = MAX_RULE_LEN;
01124 typeToStringParser(&p, &s, 0, 0, ruleNode->subtrees[1]);
01125 rstrcpy(ruleIdStr, "", MAX_NAME_LEN);
01126 break;
01127 }
01128 generalRowInsertInp.tableName = "ruleTable";
01129 generalRowInsertInp.arg1 = baseName;
01130 sprintf(mapPriorityStr, "%i", mapPriorityInt);
01131 mapPriorityInt++;
01132 generalRowInsertInp.arg2 = mapPriorityStr;
01133 generalRowInsertInp.arg3 = ruleNode->subtrees[0]->text;
01134 generalRowInsertInp.arg4 = ruleNameStr;
01135 generalRowInsertInp.arg5 = ruleCondStr;
01136 generalRowInsertInp.arg6 = ruleActionRecoveryStr;
01137 generalRowInsertInp.arg7 = ruleType;
01138 generalRowInsertInp.arg8 = ruleIdStr;
01139 generalRowInsertInp.arg9 = myTime;
01140
01141 rc1 = rsGeneralRowInsert(rei->rsComm, &generalRowInsertInp);
01142 if (rc1 < 0) {
01143 endTransactionInp.arg0 = "rollback";
01144 rsEndTransaction(rei->rsComm, &endTransactionInp);
01145 return(rc1);
01146 }
01147 }
01148
01149 endTransactionInp.arg0 = "commit";
01150 rc1 = rsEndTransaction(rei->rsComm, &endTransactionInp);
01151 return(rc1);
01152 }
01153
01154 int
01155 insertRulesIntoDB(char * baseName, ruleStruct_t *coreRuleStruct,
01156 ruleExecInfo_t *rei)
01157 {
01158 generalRowInsertInp_t generalRowInsertInp;
01159 char ruleIdStr[MAX_NAME_LEN];
01160 int rc1, i;
01161 int mapPriorityInt = 1;
01162 char mapPriorityStr[50];
01163 endTransactionInp_t endTransactionInp;
01164 char myTime[50];
01165
01166 memset (&endTransactionInp, 0, sizeof (endTransactionInp_t));
01167 getNowStr(myTime);
01168
01169
01170 generalRowInsertInp.tableName = "versionRuleBase";
01171 generalRowInsertInp.arg1 = baseName;
01172 generalRowInsertInp.arg2 = myTime;
01173
01174 rc1 = rsGeneralRowInsert(rei->rsComm, &generalRowInsertInp);
01175 if (rc1 < 0) {
01176 endTransactionInp.arg0 = "rollback";
01177 rsEndTransaction(rei->rsComm, &endTransactionInp);
01178 return(rc1);
01179 }
01180
01181 for (i = 0; i < coreRuleStruct->MaxNumOfRules; i++) {
01182 generalRowInsertInp.tableName = "ruleTable";
01183 generalRowInsertInp.arg1 = baseName;
01184 sprintf(mapPriorityStr, "%i", mapPriorityInt);
01185 mapPriorityInt++;
01186 generalRowInsertInp.arg2 = mapPriorityStr;
01187 generalRowInsertInp.arg3 = coreRuleStruct->action[i];
01188 generalRowInsertInp.arg4 = coreRuleStruct->ruleHead[i];
01189 generalRowInsertInp.arg5 = coreRuleStruct->ruleCondition[i];
01190 generalRowInsertInp.arg6 = coreRuleStruct->ruleAction[i];
01191 generalRowInsertInp.arg7= coreRuleStruct->ruleRecovery[i];
01192 generalRowInsertInp.arg8 = ruleIdStr;
01193 generalRowInsertInp.arg9 = myTime;
01194
01195 rc1 = rsGeneralRowInsert(rei->rsComm, &generalRowInsertInp);
01196 if (rc1 < 0) {
01197 endTransactionInp.arg0 = "rollback";
01198 rsEndTransaction(rei->rsComm, &endTransactionInp);
01199 return(rc1);
01200 }
01201 }
01202
01203 endTransactionInp.arg0 = "commit";
01204 rc1 = rsEndTransaction(rei->rsComm, &endTransactionInp);
01205 return(rc1);
01206 }
01207
01208 int
01209 insertDVMapsIntoDB(char * baseName, dvmStruct_t *coreDVMStruct,
01210 ruleExecInfo_t *rei)
01211 {
01212 generalRowInsertInp_t generalRowInsertInp;
01213 int rc1, i;
01214 endTransactionInp_t endTransactionInp;
01215 char myTime[50];
01216
01217 memset (&endTransactionInp, 0, sizeof (endTransactionInp_t));
01218 getNowStr(myTime);
01219
01220
01221 generalRowInsertInp.tableName = "versionDVMBase";
01222 generalRowInsertInp.arg1 = baseName;
01223 generalRowInsertInp.arg2 = myTime;
01224
01225 rc1 = rsGeneralRowInsert(rei->rsComm, &generalRowInsertInp);
01226 if (rc1 < 0) {
01227 endTransactionInp.arg0 = "rollback";
01228 rsEndTransaction(rei->rsComm, &endTransactionInp);
01229 return(rc1);
01230 }
01231
01232 for (i = 0; i < coreDVMStruct->MaxNumOfDVars; i++) {
01233 generalRowInsertInp.tableName = "dvmTable";
01234 generalRowInsertInp.arg1 = baseName;
01235 generalRowInsertInp.arg2 = coreDVMStruct->varName[i];
01236 generalRowInsertInp.arg3 = coreDVMStruct->action[i];
01237 generalRowInsertInp.arg4 = coreDVMStruct->var2CMap[i];
01238 generalRowInsertInp.arg5 = myTime;
01239
01240 rc1 = rsGeneralRowInsert(rei->rsComm, &generalRowInsertInp);
01241 if (rc1 < 0) {
01242 endTransactionInp.arg0 = "rollback";
01243 rsEndTransaction(rei->rsComm, &endTransactionInp);
01244 return(rc1);
01245 }
01246 }
01247
01248 endTransactionInp.arg0 = "commit";
01249 rc1 = rsEndTransaction(rei->rsComm, &endTransactionInp);
01250 return(rc1);
01251 }
01252
01253 int
01254 insertFNMapsIntoDB(char * baseName, fnmapStruct_t *coreFNMStruct,
01255 ruleExecInfo_t *rei)
01256 {
01257 generalRowInsertInp_t generalRowInsertInp;
01258 int rc1, i;
01259 endTransactionInp_t endTransactionInp;
01260 char myTime[50];
01261
01262 memset (&endTransactionInp, 0, sizeof (endTransactionInp_t));
01263 getNowStr(myTime);
01264
01265
01266 generalRowInsertInp.tableName = "versionFNMBase";
01267 generalRowInsertInp.arg1 = baseName;
01268 generalRowInsertInp.arg2 = myTime;
01269
01270 rc1 = rsGeneralRowInsert(rei->rsComm, &generalRowInsertInp);
01271 if (rc1 < 0) {
01272 endTransactionInp.arg0 = "rollback";
01273 rsEndTransaction(rei->rsComm, &endTransactionInp);
01274 return(rc1);
01275 }
01276
01277 for (i = 0; i < coreFNMStruct->MaxNumOfFMaps; i++) {
01278 generalRowInsertInp.tableName = "fnmTable";
01279 generalRowInsertInp.arg1 = baseName;
01280 generalRowInsertInp.arg2 = coreFNMStruct->funcName[i];
01281 generalRowInsertInp.arg3 = coreFNMStruct->func2CMap[i];
01282 generalRowInsertInp.arg4 = myTime;
01283
01284 rc1 = rsGeneralRowInsert(rei->rsComm, &generalRowInsertInp);
01285 if (rc1 < 0) {
01286 endTransactionInp.arg0 = "rollback";
01287 rsEndTransaction(rei->rsComm, &endTransactionInp);
01288 return(rc1);
01289 }
01290 }
01291
01292 endTransactionInp.arg0 = "commit";
01293 rc1 = rsEndTransaction(rei->rsComm, &endTransactionInp);
01294 return(rc1);
01295 }
01296
01297
01298
01299 int
01300 insertMSrvcsIntoDB(msrvcStruct_t *coreMsrvcStruct,
01301 ruleExecInfo_t *rei)
01302 {
01303
01304 generalRowInsertInp_t generalRowInsertInp;
01305 int rc1, i;
01306 endTransactionInp_t endTransactionInp;
01307 char myTime[100];
01308 char myStatus[100];
01309 memset (&endTransactionInp, 0, sizeof (endTransactionInp_t));
01310 getNowStr(myTime);
01311
01312 for (i = 0; i < coreMsrvcStruct->MaxNumOfMsrvcs; i++) {
01313 generalRowInsertInp.tableName = "msrvcTable";
01314 generalRowInsertInp.arg1 = coreMsrvcStruct->moduleName[i];
01315 generalRowInsertInp.arg2 = coreMsrvcStruct->msrvcName[i];
01316 generalRowInsertInp.arg3 = coreMsrvcStruct->msrvcSignature[i];
01317 generalRowInsertInp.arg4 = coreMsrvcStruct->msrvcVersion[i];
01318 generalRowInsertInp.arg5 = coreMsrvcStruct->msrvcHost[i];
01319 generalRowInsertInp.arg6 = coreMsrvcStruct->msrvcLocation[i];
01320 generalRowInsertInp.arg7 = coreMsrvcStruct->msrvcLanguage[i];
01321 generalRowInsertInp.arg8 = coreMsrvcStruct->msrvcTypeName[i];
01322 snprintf(myStatus,100, "%ld", coreMsrvcStruct->msrvcStatus[i]);
01323 generalRowInsertInp.arg9 = myStatus;
01324 generalRowInsertInp.arg10 = myTime;
01325
01326
01327 rc1 = rsGeneralRowInsert(rei->rsComm, &generalRowInsertInp);
01328 if (rc1 < 0) {
01329 endTransactionInp.arg0 = "rollback";
01330 rsEndTransaction(rei->rsComm, &endTransactionInp);
01331 return(rc1);
01332 }
01333 }
01334
01335 endTransactionInp.arg0 = "commit";
01336 rc1 = rsEndTransaction(rei->rsComm, &endTransactionInp);
01337 return(rc1);
01338
01339 }
01340
01341
01342 int
01343 writeRulesIntoFile(char * inFileName, ruleStruct_t *myRuleStruct,
01344 ruleExecInfo_t *rei)
01345 {
01346
01347 int i;
01348 FILE *file;
01349 char fileName[MAX_NAME_LEN];
01350 char *configDir;
01351
01352 if (inFileName[0] == '/' || inFileName[0] == '\\' ||
01353 inFileName[1] == ':') {
01354 snprintf (fileName,MAX_NAME_LEN, "%s",inFileName);
01355 }
01356 else {
01357 configDir = getConfigDir ();
01358 snprintf (fileName,MAX_NAME_LEN, "%s/reConfigs/%s.irb", configDir,inFileName);
01359 }
01360
01361
01362 file = fopen(fileName, "w");
01363 if (file == NULL) {
01364 rodsLog(LOG_NOTICE,
01365 "writeRulesIntoFile() could not open rules file %s for writing\n",
01366 fileName);
01367 return(FILE_OPEN_ERR);
01368 }
01369 for( i = 0; i < myRuleStruct->MaxNumOfRules; i++) {
01370 fprintf(file, "%s|%s|%s|%s|%ld\n", myRuleStruct->ruleHead[i],
01371 myRuleStruct->ruleCondition[i],
01372 myRuleStruct->ruleAction[i],
01373 myRuleStruct->ruleRecovery[i],
01374 myRuleStruct->ruleId[i]);
01375
01376 }
01377 fclose (file);
01378 return(0);
01379 }
01380
01381 int
01382 writeDVMapsIntoFile(char * inFileName, dvmStruct_t *myDVMapStruct,
01383 ruleExecInfo_t *rei)
01384 {
01385 int i;
01386 FILE *file;
01387 char fileName[MAX_NAME_LEN];
01388 char *configDir;
01389
01390 if (inFileName[0] == '/' || inFileName[0] == '\\' ||
01391 inFileName[1] == ':') {
01392 snprintf (fileName,MAX_NAME_LEN, "%s",inFileName);
01393 }
01394 else {
01395 configDir = getConfigDir ();
01396 snprintf (fileName,MAX_NAME_LEN, "%s/reConfigs/%s.dvm", configDir,inFileName);
01397 }
01398
01399 file = fopen(fileName, "w");
01400 if (file == NULL) {
01401 rodsLog(LOG_NOTICE,
01402 "writeDVMapsIntoFile() could not open rules file %s for writing\n",
01403 fileName);
01404 return(FILE_OPEN_ERR);
01405 }
01406 for( i = 0; i < myDVMapStruct->MaxNumOfDVars; i++) {
01407 fprintf(file, "%s|%s|%s|%ld\n", myDVMapStruct->varName[i],
01408 myDVMapStruct->action[i],
01409 myDVMapStruct->var2CMap[i],
01410 myDVMapStruct->varId[i]);
01411 }
01412 fclose (file);
01413 return(0);
01414 }
01415
01416
01417 int
01418 writeFNMapsIntoFile(char * inFileName, fnmapStruct_t *myFNMapStruct,
01419 ruleExecInfo_t *rei)
01420 {
01421 int i;
01422 FILE *file;
01423 char fileName[MAX_NAME_LEN];
01424 char *configDir;
01425
01426 if (inFileName[0] == '/' || inFileName[0] == '\\' ||
01427 inFileName[1] == ':') {
01428 snprintf (fileName,MAX_NAME_LEN, "%s",inFileName);
01429 }
01430 else {
01431 configDir = getConfigDir ();
01432 snprintf (fileName,MAX_NAME_LEN, "%s/reConfigs/%s.fnm", configDir,inFileName);
01433 }
01434
01435 file = fopen(fileName, "w");
01436 if (file == NULL) {
01437 rodsLog(LOG_NOTICE,
01438 "writeFNMapsIntoFile() could not open rules file %s for writing\n",
01439 fileName);
01440 return(FILE_OPEN_ERR);
01441 }
01442 for( i = 0; i < myFNMapStruct->MaxNumOfFMaps; i++) {
01443 fprintf(file, "%s|%s|%ld\n", myFNMapStruct->funcName[i],
01444 myFNMapStruct->func2CMap[i],
01445 myFNMapStruct->fmapId[i]);
01446 }
01447 fclose (file);
01448 return(0);
01449 }
01450
01451
01452
01453 int
01454 writeMSrvcsIntoFile(char * inFileName, msrvcStruct_t *myMsrvcStruct,
01455 ruleExecInfo_t *rei)
01456 {
01457 int i;
01458 FILE *file;
01459 char fileName[MAX_NAME_LEN];
01460 char *configDir;
01461
01462 if (inFileName[0] == '/' || inFileName[0] == '\\' ||
01463 inFileName[1] == ':') {
01464 snprintf (fileName,MAX_NAME_LEN, "%s",inFileName);
01465 }
01466 else {
01467 configDir = getConfigDir ();
01468 snprintf (fileName,MAX_NAME_LEN, "%s/reConfigs/%s.msi", configDir,inFileName);
01469 }
01470
01471 file = fopen(fileName, "w");
01472 if (file == NULL) {
01473 rodsLog(LOG_NOTICE,
01474 "writeMsrvcsIntoFile() could not open microservics file %s for writing\n",
01475 fileName);
01476 return(FILE_OPEN_ERR);
01477 }
01478 for( i = 0; i < myMsrvcStruct->MaxNumOfMsrvcs; i++) {
01479 fprintf(file, "%s|%s|%s|%s|%s|%s|%s|%s|%ld|%ld\n",
01480 myMsrvcStruct->moduleName[i],
01481 myMsrvcStruct->msrvcName[i],
01482 myMsrvcStruct->msrvcSignature[i],
01483 myMsrvcStruct->msrvcVersion[i],
01484 myMsrvcStruct->msrvcHost[i],
01485 myMsrvcStruct->msrvcLocation[i],
01486 myMsrvcStruct->msrvcLanguage[i],
01487 myMsrvcStruct->msrvcTypeName[i],
01488 myMsrvcStruct->msrvcStatus[i],
01489 myMsrvcStruct->msrvcId[i]);
01490 }
01491 fclose (file);
01492 return(0);
01493 }
01494
01495 int
01496 finalzeRuleEngine(rsComm_t *rsComm)
01497 {
01498 clearDVarStruct( &coreRuleVarDef );
01499 clearFuncMapStruct( &coreRuleFuncMapDef );
01500 clearRuleStruct( &coreRuleStrct );
01501
01502 if ( GlobalREDebugFlag > 5 ) {
01503 _writeXMsg(GlobalREDebugFlag, "idbug", "PROCESS END");
01504 }
01505 return(0);
01506 }
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538
01539
01540
01541
01542
01543
01544