00001
00002
00003
00004 #include "reHelpers1.h"
00005
00006 #include "index.h"
00007 #include "parser.h"
00008 #include "filesystem.h"
00009 #include "configuration.h"
00010
00011 struct Breakpoint {
00012 char *actionName;
00013 char *base;
00014 int pending;
00015 int row;
00016 int line;
00017 rodsLong_t start;
00018 rodsLong_t finish;
00019 } breakPoints[100];
00020
00021 int breakPointsInx = 0;
00022
00023 int reDebugPCType(RuleEngineEvent label);
00024 void printRuleEngineEventLabel(char buf[], size_t n, RuleEngineEvent label, RuleEngineEventParam *param);
00025
00026
00027 void disableReDebugger(int grdf[2]) {
00028 grdf[0] = GlobalREAuditFlag;
00029 grdf[1] = GlobalREDebugFlag;
00030 GlobalREAuditFlag = 0;
00031 GlobalREDebugFlag = 0;
00032
00033 }
00034
00035 void enableReDebugger(int grdf[2]) {
00036 GlobalREAuditFlag = grdf[0];
00037 GlobalREDebugFlag = grdf[1];
00038
00039 }
00040 char myHostName[MAX_NAME_LEN];
00041 char waitHdr[HEADER_TYPE_LEN];
00042 char waitMsg[MAX_NAME_LEN];
00043 int myPID;
00044
00045 int initializeReDebug(rsComm_t *svrComm, int flag)
00046 {
00047 char condRead[NAME_LEN];
00048 int i, s,m, status;
00049 char *readhdr = NULL;
00050 char *readmsg = NULL;
00051 char *user = NULL;
00052 char *addr = NULL;
00053
00054 if (svrComm == NULL)
00055 return(0);
00056 if ( GlobalREDebugFlag != 4 )
00057 return(0);
00058
00059 s=0;
00060 m=0;
00061 myPID = (int) getpid();
00062 myHostName[0] = '\0';
00063 gethostname (myHostName, MAX_NAME_LEN);
00064 sprintf(condRead, "(*XUSER == \"%s@%s\") && (*XHDR == \"STARTDEBUG\")",
00065 svrComm->clientUser.userName, svrComm->clientUser.rodsZone);
00066 status = _readXMsg(GlobalREDebugFlag, condRead, &m, &s, &readhdr, &readmsg, &user, &addr);
00067 if (status >= 0) {
00068 if ( (readmsg != NULL) && strlen(readmsg) > 0) {
00069 GlobalREDebugFlag = atoi(readmsg);
00070 }
00071 if (readhdr != NULL)
00072 free(readhdr);
00073 if (readmsg != NULL)
00074 free(readmsg);
00075 if (user != NULL)
00076 free(user);
00077 if (addr != NULL)
00078 free(addr);
00079
00080 for (i = 0; i < REDEBUG_STACK_SIZE_FULL; i++)
00081 reDebugStackFull[i] = NULL;
00082 for (i = 0; i < REDEBUG_STACK_SIZE_CURR; i++) {
00083 reDebugStackCurr[i].label = -1;
00084 reDebugStackCurr[i].step = NULL;
00085 }
00086 memset(breakPoints, 0, sizeof(struct Breakpoint) * 100);
00087
00088 reDebugStackFullPtr = 0;
00089 reDebugStackCurrPtr = 0;
00090 snprintf(waitHdr,HEADER_TYPE_LEN - 1, "idbug:");
00091
00092 rodsLog (LOG_NOTICE,"reDebugInitialization: Got Debug StreamId:%i\n",GlobalREDebugFlag);
00093 snprintf(waitMsg, MAX_NAME_LEN, "PROCESS BEGIN at %s:%i. Client connected from %s at port %i\n",
00094 myHostName, myPID, svrComm->clientAddr,ntohs(svrComm->localAddr.sin_port));
00095 _writeXMsg(GlobalREDebugFlag, "idbug", waitMsg);
00096 snprintf(waitMsg, MAX_NAME_LEN, "%s:%i is waiting\n", myHostName, myPID); }
00097 return(0);
00098 }
00099
00100
00101 int processXMsg(int streamId, int *msgNum, int *seqNum,
00102 char * readhdr, char *readmsg,
00103 RuleEngineEvent label, RuleEngineEventParam *param, Node *node,
00104 Env *env, int curStat, ruleExecInfo_t *rei)
00105 {
00106
00107 char myhdr[HEADER_TYPE_LEN];
00108 char mymsg[MAX_NAME_LEN];
00109 char *outStr = NULL;
00110 char *ptr;
00111 int i,n;
00112 int iLevel, wCnt;
00113 int ruleInx = 0;
00114 Region *r;
00115 Res *res;
00116 rError_t errmsg;
00117 errmsg.len = 0;
00118 errmsg.errMsg = NULL;
00119 r = make_region(0, NULL);
00120 ParserContext *context = newParserContext(&errmsg, r);
00121 Pointer *e = newPointer2(readmsg);
00122 int rulegen = 1;
00123 int found;
00124 int grdf[2];
00125 int cmd = 0;
00126 int smallW;
00127 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug:%s",param->actionName);
00128 PARSER_BEGIN(DbgCmd)
00129 TRY(DbgCmd)
00130 TTEXT2("n", "next");
00131 cmd = REDEBUG_STEP_OVER;
00132 OR(DbgCmd)
00133 TTEXT2("s", "step");
00134 cmd = REDEBUG_NEXT;
00135 OR(DbgCmd)
00136 TTEXT2("f", "finish");
00137 cmd = REDEBUG_STEP_OUT;
00138 OR(DbgCmd)
00139 TTEXT2("b", "break");
00140 TRY(Param)
00141 TTYPE(TK_TEXT);
00142 char *fn = strdup(token->text);
00143 int breakPointsInx2;
00144 for(breakPointsInx2=0;breakPointsInx2<100;breakPointsInx2++) {
00145 if(breakPoints[breakPointsInx2].actionName == NULL) {
00146 break;
00147 }
00148 }
00149 if(breakPointsInx2 == 100) {
00150 _writeXMsg(streamId, myhdr, "Maximum breakpoint count reached. Breakpoint not set.\n");
00151 cmd = REDEBUG_WAIT;
00152 } else {
00153 breakPoints[breakPointsInx2].actionName = fn;
00154 ptr = NULL;
00155 TRY(loc)
00156 TTYPE(TK_TEXT);
00157 ptr = (char *) malloc(sizeof(token->text) + 2);
00158 ptr[0] = 'f';
00159 strcpy(ptr+1, token->text);
00160 TTEXT(":");
00161 TTYPE(TK_INT);
00162 breakPoints[breakPointsInx2].base = ptr;
00163 breakPoints[breakPointsInx2].line = atoi(token->text);
00164 rodsLong_t range[2];
00165 char rulesFileName[MAX_NAME_LEN];
00166 getRuleBasePath(ptr, rulesFileName);
00167
00168 FILE *file;
00169
00170 file = fopen(rulesFileName, "r");
00171 if (file == NULL) {
00172 return(RULES_FILE_READ_ERROR);
00173 }
00174 Pointer *p = newPointer(file, ptr);
00175
00176
00177 if(getLineRange(p, breakPoints[breakPointsInx2].line, range) == 0) {
00178 breakPoints[breakPointsInx2].start = range[0];
00179 breakPoints[breakPointsInx2].finish = range[1];
00180 } else {
00181 breakPoints[breakPointsInx2].actionName = NULL;
00182 }
00183 deletePointer(p);
00184 OR(loc)
00185 TTYPE(TK_INT);
00186 if(node!=NULL) {
00187 breakPoints[breakPointsInx2].base = strdup(node->base);
00188 breakPoints[breakPointsInx2].line = atoi(token->text);
00189 rodsLong_t range[2];
00190 Pointer *p = newPointer2(breakPoints[breakPointsInx2].base);
00191 if(getLineRange(p, breakPoints[breakPointsInx2].line, range) == 0) {
00192 breakPoints[breakPointsInx2].start = range[0];
00193 breakPoints[breakPointsInx2].finish = range[1];
00194 } else {
00195 breakPoints[breakPointsInx2].actionName = NULL;
00196 }
00197 deletePointer(p);
00198 } else {
00199 breakPoints[breakPointsInx2].actionName = NULL;
00200 }
00201 OR(loc)
00202
00203 END_TRY(loc)
00204
00205 if(ptr!=NULL && breakPoints[breakPointsInx2].base == NULL) {
00206 free(ptr);
00207 }
00208 if(breakPoints[breakPointsInx2].actionName != NULL)
00209 snprintf(mymsg, MAX_NAME_LEN, "Breakpoint %i set at %s\n", breakPointsInx2,
00210 breakPoints[breakPointsInx2].actionName);
00211 else
00212 snprintf(mymsg, MAX_NAME_LEN, "Cannot set breakpoint, source not available\n");
00213 _writeXMsg(streamId, myhdr, mymsg);
00214 if(breakPointsInx <= breakPointsInx2) {
00215 breakPointsInx = breakPointsInx2 + 1;
00216 }
00217 cmd = REDEBUG_WAIT;
00218 }
00219 OR(Param)
00220 NEXT_TOKEN_BASIC;
00221 _writeXMsg(streamId, myhdr, "Unknown parameter type.\n");
00222 cmd = REDEBUG_WAIT;
00223 OR(Param)
00224 _writeXMsg(streamId, myhdr, "Debugger command \'break\' requires at least one argument.\n");
00225 cmd = REDEBUG_WAIT;
00226 END_TRY(Param)
00227
00228 OR(DbgCmd)
00229 TRY(Where)
00230 TTEXT2("w", "where");
00231 smallW=1;
00232 OR(Where)
00233 TTEXT2("W", "Where");
00234 smallW=0;
00235 END_TRY(Where)
00236 wCnt = 20;
00237 OPTIONAL_BEGIN(Param)
00238 TTYPE(TK_INT);
00239 wCnt = atoi(token->text);
00240 OPTIONAL_END(Param)
00241 iLevel = 0;
00242
00243 i = reDebugStackCurrPtr - 1;
00244 while (i >=0 && wCnt > 0) {
00245 if (!smallW || (reDebugPCType((RuleEngineEvent) reDebugStackCurr[i].label) & 1) != 0) {
00246 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Level %3i",iLevel);
00247 char msg[HEADER_TYPE_LEN - 1];
00248 RuleEngineEventParam param;
00249 param.actionName = reDebugStackCurr[i].step;
00250 printRuleEngineEventLabel(msg, HEADER_TYPE_LEN - 1, (RuleEngineEvent) reDebugStackCurr[i].label, ¶m);
00251 _writeXMsg(streamId, myhdr, msg);
00252 if (reDebugStackCurr[i].label != EXEC_ACTION_BEGIN)
00253 iLevel++;
00254 wCnt--;
00255 }
00256 i--;
00257 }
00258 OR(DbgCmd)
00259 TTEXT2("l", "list");
00260 TRY(Param)
00261 TTEXT2("r", "rule");
00262 TRY(ParamParam)
00263 TTYPE(TK_TEXT);
00264 ptr = strdup(token->text);
00265
00266 mymsg[0] = '\n';
00267 mymsg[1] = '\0';
00268 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s",ptr);
00269 RuleIndexListNode *node;
00270 found = 0;
00271 while (findNextRule2 (ptr, ruleInx, &node) != NO_MORE_RULES_ERR) {
00272 found = 1;
00273 if(node->secondaryIndex) {
00274 n = node->condIndex->valIndex->len;
00275 int i;
00276 for(i=0;i<n;i++) {
00277 Bucket *b = node->condIndex->valIndex->buckets[i];
00278 while(b!=NULL) {
00279 RuleDesc *rd = getRuleDesc(*(int *)b->value);
00280 char buf[MAX_RULE_LEN];
00281 ruleToString(buf, MAX_RULE_LEN, rd);
00282 snprintf(mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg), "%i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's'? "<source>":rd->node->base + 1, buf);
00283 b = b->next;
00284 }
00285 }
00286 } else {
00287 RuleDesc *rd = getRuleDesc(node->ruleIndex);
00288 char buf[MAX_RULE_LEN];
00289 ruleToString(buf, MAX_RULE_LEN, rd);
00290 snprintf(mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg), "\n %i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's'? "<source>":rd->node->base + 1, buf);
00291 }
00292 ruleInx ++;
00293 }
00294 if (!found) {
00295 snprintf(mymsg, MAX_NAME_LEN,"Rule %s not found\n", ptr);
00296 }
00297 _writeXMsg(streamId, myhdr, mymsg);
00298 cmd = REDEBUG_WAIT;
00299 OR(ParamParam)
00300 _writeXMsg(streamId, myhdr, "Debugger command \'list rule\' requires one argument.\n");
00301 cmd = REDEBUG_WAIT;
00302 END_TRY(ParamParam)
00303 OR(Param)
00304 TTEXT2("b", "breakpoints");
00305 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s",token->text);
00306 mymsg[0] = '\n';
00307 mymsg[1] = '\0';
00308 for(i=0;i<breakPointsInx;i++) {
00309 if(breakPoints[i].actionName!=NULL) {
00310 if(breakPoints[i].base!=NULL) {
00311 snprintf(mymsg + strlen(mymsg),MAX_NAME_LEN - strlen(mymsg), "Breaking at BreakPoint %i:%s %s:%d\n", i , breakPoints[i].actionName, breakPoints[i].base[0]=='s'?"<source>":breakPoints[i].base+1, breakPoints[i].line);
00312 } else {
00313 snprintf(mymsg + strlen(mymsg),MAX_NAME_LEN - strlen(mymsg), "Breaking at BreakPoint %i:%s\n", i , breakPoints[i].actionName);
00314 }
00315 }
00316 }
00317 _writeXMsg(streamId, myhdr, mymsg);
00318 cmd = REDEBUG_WAIT;
00319 OR(Param)
00320 TTEXT("*");
00321 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s",token->text);
00322 Env *cenv = env;
00323 mymsg[0] = '\n';
00324 mymsg[1] = '\0';
00325 found = 0;
00326 while(cenv!=NULL) {
00327 n = cenv->current->size;
00328 for(i = 0;i<n;i++) {
00329 Bucket *b = cenv->current->buckets[i];
00330 while(b!=NULL) {
00331 if(b->key[0] == '*') {
00332 found = 1;
00333 char typeString[128];
00334 typeToString(((Res *)b->value)->exprType, NULL, typeString, 128);
00335 snprintf(mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg), "%s of type %s\n", b->key, typeString);
00336 }
00337 b = b->next;
00338 }
00339 }
00340 cenv = cenv->previous;
00341 }
00342 if (!found) {
00343 snprintf(mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg), "<empty>\n");
00344 }
00345 _writeXMsg(streamId, myhdr, mymsg);
00346 cmd = REDEBUG_WAIT;
00347 OR(Param)
00348 syncTokenQueue(e, context);
00349 skipWhitespace(e);
00350 ABORT(lookAhead(e, 0) != '$');
00351 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s",token->text);
00352 mymsg[0] = '\n';
00353 mymsg[1] = '\0';
00354 Hashtable *vars = newHashTable(100);
00355 for (i= 0; i < coreRuleVarDef .MaxNumOfDVars; i++) {
00356 if(lookupFromHashTable(vars, coreRuleVarDef.varName[i])==NULL) {
00357 snprintf(&mymsg[strlen(mymsg)], MAX_NAME_LEN - strlen(mymsg), "$%s\n", coreRuleVarDef.varName[i]);
00358 insertIntoHashTable(vars, coreRuleVarDef.varName[i], coreRuleVarDef.varName[i]);
00359 }
00360 }
00361 deleteHashTable(vars, NULL);
00362 _writeXMsg(streamId, myhdr, mymsg);
00363 cmd = REDEBUG_WAIT;
00364 OR(Param)
00365 NEXT_TOKEN_BASIC;
00366 _writeXMsg(streamId, myhdr, "Unknown parameter type.\n");
00367 cmd = REDEBUG_WAIT;
00368 OR(Param)
00369 _writeXMsg(streamId, myhdr, "Debugger command \'list\' requires at least one argument.\n");
00370 cmd = REDEBUG_WAIT;
00371 END_TRY(Param)
00372 OR(DbgCmd)
00373 TTEXT2("c", "continue");
00374 cmd = REDEBUG_STEP_CONTINUE;
00375 OR(DbgCmd)
00376 TTEXT2("C", "Continue");
00377 cmd = REDEBUG_CONTINUE_VERBOSE;
00378 OR(DbgCmd)
00379 TTEXT2("del", "delete");
00380 TRY(Param)
00381 TTYPE(TK_INT);
00382 n = atoi(token->text);
00383 if(breakPoints[n].actionName!= NULL) {
00384 free(breakPoints[n].actionName);
00385 if(breakPoints[n].base != NULL) {
00386 free(breakPoints[n].base);
00387 }
00388 breakPoints[n].actionName = NULL;
00389 breakPoints[n].base = NULL;
00390 snprintf(mymsg, MAX_NAME_LEN, "Breakpoint %i deleted\n", n);
00391 } else {
00392 snprintf(mymsg, MAX_NAME_LEN, "Breakpoint %i has not been defined\n", n);
00393 }
00394 _writeXMsg(streamId, myhdr, mymsg);
00395 cmd = REDEBUG_WAIT;
00396 OR(Param)
00397 _writeXMsg(streamId, myhdr, "Debugger command \'delete\' requires one argument.\n");
00398 cmd = REDEBUG_WAIT;
00399 END_TRY(Param)
00400 OR(DbgCmd)
00401 TTEXT2("p", "print");
00402 Node *n = parseTermRuleGen(e, 1, context);
00403 if(getNodeType(n) == N_ERROR) {
00404 errMsgToString(context->errmsg, mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg));
00405 } else {
00406 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug: Printing ");
00407 ptr = myhdr + strlen(myhdr);
00408 i = HEADER_TYPE_LEN - 1 - strlen(myhdr);
00409 termToString(&ptr, &i, 0, MIN_PREC, n, 0);
00410 snprintf(ptr, i, "\n");
00411 if(env != NULL) {
00412 disableReDebugger(grdf);
00413 res = computeNode(n, NULL, regionRegionCpEnv(env, r, (RegionRegionCopyFuncType *) regionRegionCpNode), rei, 0, &errmsg, r);
00414 enableReDebugger(grdf);
00415 outStr = convertResToString(res);
00416 snprintf(mymsg, MAX_NAME_LEN, "%s\n", outStr);
00417 free(outStr);
00418 if(getNodeType(res) == N_ERROR) {
00419 errMsgToString(&errmsg, mymsg + strlen(mymsg), MAX_NAME_LEN - strlen(mymsg));
00420 }
00421 } else {
00422 snprintf(mymsg, MAX_NAME_LEN, "Runtime environment: <empty>\n");
00423 }
00424 }
00425 _writeXMsg(streamId, myhdr, mymsg);
00426
00427 cmd = REDEBUG_WAIT;
00428 OR(DbgCmd)
00429 TTEXT2("d", "discontinue");
00430 cmd = REDEBUG_WAIT;
00431 OR(DbgCmd)
00432 snprintf(mymsg, MAX_NAME_LEN, "Unknown Action: %s", readmsg);
00433 _writeXMsg(streamId, myhdr, mymsg);
00434 cmd = REDEBUG_WAIT;
00435 END_TRY(DbgCmd)
00436 PARSER_END(DbgCmd)
00437 freeRErrorContent(&errmsg);
00438 region_free(r);
00439 deletePointer(e);
00440 return cmd;
00441 }
00442
00443 int
00444 processBreakPoint(int streamId, int *msgNum, int *seqNum,
00445 RuleEngineEvent label, RuleEngineEventParam *param, Node *node,
00446 Env *env, int curStat, ruleExecInfo_t *rei)
00447 {
00448
00449 int i;
00450 char myhdr[HEADER_TYPE_LEN];
00451 char mymsg[MAX_NAME_LEN];
00452
00453 snprintf(myhdr, HEADER_TYPE_LEN - 1, "idbug:%s",param->actionName);
00454
00455
00456 if (breakPointsInx > 0) {
00457 for (i = 0; i < breakPointsInx; i++) {
00458 if (breakPoints[i].actionName!=NULL) {
00459 int len = strlen(breakPoints[i].actionName);
00460
00461 if(strncmp(param->actionName, breakPoints[i].actionName, len) == 0) {
00462 if(breakPoints[i].base != NULL &&
00463 (node == NULL || node->expr < breakPoints[i].start || node->expr >= breakPoints[i].finish ||
00464 strcmp(node->base, breakPoints[i].base)!=0)) {
00465 continue;
00466 }
00467 char buf[MAX_NAME_LEN];
00468 snprintf(buf,MAX_NAME_LEN, "Breaking at BreakPoint %i:%s\n", i , breakPoints[i].actionName);
00469 generateErrMsg(buf, node->expr, node->base, mymsg);
00470 _writeXMsg(streamId, myhdr, mymsg);
00471 snprintf(mymsg,MAX_NAME_LEN, "%s\n", param->actionName);
00472 _writeXMsg(streamId, myhdr, mymsg);
00473 curStat = REDEBUG_WAIT;
00474 return(curStat);
00475 }
00476 }
00477 }
00478 }
00479 return(curStat);
00480 }
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503 int
00504 popReStack(RuleEngineEvent label, char* step)
00505 {
00506
00507 int i;
00508 i = reDebugStackCurrPtr - 1;
00509 while (i >= 0 && (reDebugStackCurr[i].label != label || strcmp(reDebugStackCurr[i].step, step) != 0)) {
00510 free(reDebugStackCurr[i].step);
00511 reDebugStackCurr[i].step = NULL;
00512 reDebugStackCurr[i].label = -1;
00513 i = i - 1;
00514 }
00515 reDebugStackCurrPtr = i;
00516 return(0);
00517 }
00518
00519 int
00520 pushReStack(RuleEngineEvent label, char* step)
00521 {
00522
00523 int i;
00524 i = reDebugStackCurrPtr;
00525 if(i < REDEBUG_STACK_SIZE_CURR) {
00526 reDebugStackCurr[i].label = label;
00527 reDebugStackCurr[i].step = strdup(step);
00528 reDebugStackCurrPtr = i + 1;
00529 }
00530 return(0);
00531 }
00532
00533
00534 int sendWaitXMsg (int streamId) {
00535 _writeXMsg(streamId, waitHdr, waitMsg);
00536 return(0);
00537 }
00538 int cleanUpDebug(int streamId) {
00539 int i;
00540 for (i = 0 ; i < REDEBUG_STACK_SIZE_CURR; i++) {
00541 if (reDebugStackCurr[i].step != NULL) {
00542 free(reDebugStackCurr[i].step);
00543 reDebugStackCurr[i].step = NULL;
00544 reDebugStackCurr[i].label = -1;
00545 }
00546 }
00547 for (i = 0 ; i < REDEBUG_STACK_SIZE_FULL; i++) {
00548 if (reDebugStackFull[i] != NULL) {
00549 free(reDebugStackFull[i]);
00550 reDebugStackFull[i] = NULL;
00551 }
00552 }
00553 reDebugStackCurrPtr = 0;
00554 reDebugStackFullPtr = 0;
00555 GlobalREDebugFlag = -1;
00556 return(0);
00557 }
00558
00559 void printRuleEngineEventLabel(char buf[], size_t n, RuleEngineEvent label, RuleEngineEventParam *param) {
00560 switch(label) {
00561 case EXEC_RULE_BEGIN:
00562 snprintf(buf, n, "ExecRule:%s", param->actionName);
00563 break;
00564 case EXEC_RULE_END:
00565 snprintf(buf, n, "ExecRule Done:%s", param->actionName);
00566 break;
00567 case EXEC_ACTION_BEGIN:
00568 snprintf(buf, n, "ExecAction:%s", param->actionName);
00569 break;
00570 case EXEC_ACTION_END:
00571 snprintf(buf, n, "ExecAction Done:%s", param->actionName);
00572 break;
00573 case EXEC_MICRO_SERVICE_BEGIN:
00574 snprintf(buf, n, "ExecMicroSvrc:%s", param->actionName);
00575 break;
00576 case EXEC_MICRO_SERVICE_END:
00577 snprintf(buf, n, "ExecMicroSvrc Done:%s", param->actionName);
00578 break;
00579 case GOT_RULE:
00580 snprintf(buf, n, "GotRule:%s:%d", param->actionName, param->ruleIndex);
00581 break;
00582 case APPLY_RULE_BEGIN:
00583 snprintf(buf, n, "ApplyRule:%s", param->actionName);
00584 break;
00585 case APPLY_RULE_END:
00586 snprintf(buf, n, "ApplyRule Done:%s", param->actionName);
00587 break;
00588 case APPLY_ALL_RULES_BEGIN:
00589 snprintf(buf, n, "ApplyAllRules:%s", param->actionName);
00590 break;
00591 case APPLY_ALL_RULES_END:
00592 snprintf(buf, n, "ApplyAllRules Done:%s", param->actionName);
00593 break;
00594 case EXEC_MY_RULE_BEGIN:
00595 snprintf(buf, n, "ExecMyRule:%s", param->actionName);
00596 break;
00597 case EXEC_MY_RULE_END:
00598 snprintf(buf, n, "ExecMyRule Done:%s", param->actionName);
00599 break;
00600 }
00601 }
00602 int reDebugPCType(RuleEngineEvent label) {
00603 switch(label) {
00604 case EXEC_RULE_BEGIN:
00605 case EXEC_ACTION_BEGIN:
00606 case EXEC_MICRO_SERVICE_BEGIN:
00607 case APPLY_RULE_BEGIN:
00608 case APPLY_ALL_RULES_BEGIN:
00609 case EXEC_MY_RULE_BEGIN:
00610 return 1;
00611 case EXEC_RULE_END:
00612 case EXEC_ACTION_END:
00613 case EXEC_MICRO_SERVICE_END:
00614 case APPLY_RULE_END:
00615 case APPLY_ALL_RULES_END:
00616 case EXEC_MY_RULE_END:
00617 return 2;
00618 case GOT_RULE:
00619 return 0;
00620 }
00621 return -1;
00622 }
00623
00624
00625
00626
00627
00628
00629
00630 int
00631 reDebug(RuleEngineEvent label, int flag, RuleEngineEventParam *param, Node *node, Env *env, ruleExecInfo_t *rei)
00632 {
00633
00634 if(ruleEngineConfig.logging == 0) {
00635 return 0;
00636 }
00637 int i, m, s, status, sleepT, j;
00638 int processedBreakPoint = 0;
00639 char hdr[HEADER_TYPE_LEN];
00640 char *readhdr = NULL;
00641 char *readmsg = NULL;
00642 char *user = NULL;
00643 char *addr = NULL;
00644 static int mNum = 0;
00645 static int sNum = 0;
00646 static int curStat = 0;
00647 static int reDebugStackPtr = -1;
00648 static int reDebugStopAt = 1;
00649 char condRead[MAX_NAME_LEN];
00650 char myActionStr[10][MAX_NAME_LEN + 10];
00651 int aNum = 0;
00652 char seActionStr[10 * MAX_NAME_LEN + 100];
00653 char timestamp[TIME_LEN];
00654 rsComm_t *svrComm;
00655 int waitCnt = 0;
00656 sleepT = 1;
00657 char buf[HEADER_TYPE_LEN - 1];
00658
00659 svrComm = rei->rsComm;
00660
00661 if (svrComm == NULL) {
00662 rodsLog(LOG_ERROR, "Empty svrComm in REI structure for actionStr=%s\n",
00663 param->actionName);
00664 return(0);
00665 }
00666
00667 generateLogTimestamp(timestamp, TIME_LEN);
00668 printRuleEngineEventLabel(buf,HEADER_TYPE_LEN - 1, label, param);
00669 snprintf(hdr, HEADER_TYPE_LEN - 1, "iaudit:%s", timestamp);
00670 condRead[0] = '\0';
00671
00672 snprintf(seActionStr, MAX_NAME_LEN + 10, "%s", buf);
00673 if (GlobalREAuditFlag > 0) {
00674 if (flag == -4) {
00675 if (rei->uoic != NULL && rei->uoic->userName != NULL && rei->uoic->rodsZone != NULL) {
00676 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " USER:%s@%s", rei->uoic->userName, rei->uoic->rodsZone);
00677 aNum++;
00678 }
00679 if (rei->doi != NULL && rei->doi->objPath != NULL && strlen(rei->doi->objPath) > 0 ) {
00680 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " DATA:%s", rei->doi->objPath);
00681 aNum++;
00682 }
00683 if (rei->doi != NULL && rei->doi->filePath != NULL && strlen(rei->doi->filePath) > 0) {
00684 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " FILE:%s", rei->doi->filePath);
00685 aNum++;
00686 }
00687 if (rei->doinp != NULL && rei->doinp->objPath != NULL && strlen(rei->doinp->objPath) > 0) {
00688 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " DATAIN:%s",rei->doinp->objPath);
00689 aNum++;
00690 }
00691 if (rei->doi != NULL && rei->doi->rescName != NULL && strlen(rei->doi->rescName) > 0) {
00692 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " RESC:%s",rei->doi->rescName);
00693 aNum++;
00694 }
00695 if (rei->rgi != NULL && rei->rgi->rescInfo->rescName != NULL && strlen(rei->rgi->rescInfo->rescName) > 0) {
00696 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " RESC:%s",rei->rgi->rescInfo->rescName);
00697 aNum++;
00698 }
00699 if (rei->doi != NULL && rei->doi->rescGroupName != NULL && strlen(rei->doi->rescGroupName) > 0) {
00700 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " RESCGRP:%s",rei->doi->rescGroupName);
00701 aNum++;
00702 }
00703 if (rei->rgi != NULL && rei->rgi->rescGroupName != NULL && strlen(rei->rgi->rescGroupName) > 0) {
00704 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " RESCGRP:%s",rei->rgi->rescGroupName);
00705 aNum++;
00706 }
00707 if (rei->coi != NULL && rei->coi->collName != NULL) {
00708 snprintf(myActionStr[aNum],MAX_NAME_LEN + 10 , " COLL:%s", rei->coi->collName);
00709 aNum++;
00710 }
00711 for (j = 0; j < aNum; j++) {
00712 strncat(seActionStr, myActionStr[j], 10 * MAX_NAME_LEN + 100);
00713 }
00714 }
00715 }
00716
00717
00718 if (GlobalREAuditFlag == 3) {
00719 i = _writeXMsg(GlobalREAuditFlag, hdr, seActionStr);
00720 if (i < 0)
00721 {
00722 eirods::log( ERROR (i, "_writeXMsg failed."));
00723 }
00724 }
00725
00726
00727
00728 if ( GlobalREDebugFlag > 5 ) {
00729
00730 int pcType = reDebugPCType(label);
00731 if((pcType & 1) != 0) {
00732 pushReStack(label, param->actionName);
00733 } else if ((pcType & 2) != 0) {
00734 popReStack(label, param->actionName);
00735 }
00736
00737 if (curStat == REDEBUG_CONTINUE && reDebugStackCurrPtr <= reDebugStackPtr && (reDebugPCType(label) & reDebugStopAt) != 0) {
00738 curStat = REDEBUG_WAIT;
00739 }
00740 if (curStat != REDEBUG_CONTINUE) {
00741 snprintf(hdr, HEADER_TYPE_LEN - 1, "idbug:%s",param->actionName);
00742 i = _writeXMsg(GlobalREDebugFlag, hdr, buf);
00743 if (i < 0)
00744 {
00745 eirods::log( ERROR (i, "_writeXMsg failed."));
00746 }
00747 }
00748
00749 while ( GlobalREDebugFlag > 5 ) {
00750 s = sNum;
00751 m = mNum;
00752
00753 sprintf(condRead, "(*XSEQNUM >= %d) && (*XADDR != \"%s:%i\") && (*XUSER == \"%s@%s\") && ((*XHDR == \"CMSG:ALL\") %%%% (*XHDR == \"CMSG:%s:%i\"))",
00754 s, myHostName, myPID, svrComm->clientUser.userName, svrComm->clientUser.rodsZone, myHostName, myPID);
00755
00756
00757
00758
00759
00760 status = _readXMsg(GlobalREDebugFlag, condRead, &m, &s, &readhdr, &readmsg, &user, &addr);
00761 if (status == SYS_UNMATCHED_XMSG_TICKET) {
00762 cleanUpDebug(GlobalREDebugFlag);
00763 return(0);
00764 }
00765 if (status >= 0) {
00766 rodsLog (LOG_NOTICE,"Getting XMsg:%i:%s:%s\n", s,readhdr, readmsg);
00767 curStat = processXMsg(GlobalREDebugFlag, &m, &s, readhdr, readmsg,
00768 label,param, node,
00769 env, curStat, rei);
00770 if (readhdr != NULL)
00771 free(readhdr);
00772 if (readmsg != NULL)
00773 free(readmsg);
00774 if (user != NULL)
00775 free(user);
00776 if (addr != NULL)
00777 free(addr);
00778
00779 mNum = m;
00780 sNum = s + 1;
00781 if (curStat == REDEBUG_WAIT) {
00782 sendWaitXMsg(GlobalREDebugFlag);
00783 } else
00784 if(curStat == REDEBUG_STEP_OVER) {
00785 reDebugStackPtr = reDebugStackCurrPtr;
00786 reDebugStopAt = 1;
00787 curStat = REDEBUG_CONTINUE;
00788 break;
00789 } else
00790 if(curStat == REDEBUG_STEP_OUT) {
00791 reDebugStackPtr = reDebugStackCurrPtr - 1;
00792 reDebugStopAt = 2;
00793 curStat = REDEBUG_CONTINUE;
00794 break;
00795 } else
00796 if(curStat == REDEBUG_STEP_CONTINUE) {
00797 reDebugStackPtr = -1;
00798 curStat = REDEBUG_CONTINUE;
00799 break;
00800 } else if (curStat == REDEBUG_NEXT )
00801 break;
00802 } else {
00803 if (!(curStat == REDEBUG_CONTINUE || curStat == REDEBUG_CONTINUE_VERBOSE)) {
00804
00805
00806
00807
00808
00809
00810 sleep(sleepT);
00811 waitCnt+=100;
00812
00813 if (waitCnt > 6000) {
00814 sendWaitXMsg(GlobalREDebugFlag);
00815 waitCnt = 0;
00816 }
00817 }
00818 }
00819 if (curStat == REDEBUG_CONTINUE || curStat == REDEBUG_CONTINUE_VERBOSE) {
00820 if (processedBreakPoint == 1)
00821 break;
00822 curStat = processBreakPoint(GlobalREDebugFlag, &m, &s,
00823 label, param, node,
00824 env, curStat, rei);
00825 processedBreakPoint = 1;
00826 if (curStat == REDEBUG_WAIT) {
00827 sendWaitXMsg(GlobalREDebugFlag);
00828 continue;
00829 } else
00830 break;
00831 }
00832 }
00833 }
00834
00835
00836 return(0);
00837 }