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