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