int
modDelayedRule( char *ruleId, char *fieldName, char *fieldValue ) {
int status;
ruleExecModInp_t ruleExecModInp;
memset( &ruleExecModInp, 0, sizeof( ruleExecModInp ) );
/* for the time fields, convert from YYYY-MM-DD.hh:mm:ss in sec of unix time
if necessary */
if ( strcmp( fieldName, "exeTime" ) == 0 || strcmp( fieldName, "estimateExeTime" ) == 0 ||
strcmp( fieldName, "lastExeTime" ) == 0 ) {
status = checkDateFormat( fieldValue );
if ( status == DATE_FORMAT_ERR ) {
printf( "Time format error: it should be sec in unix time or YYYY-MM-DD.hh:mm:ss.\n" );
return status;
}
}
strncpy( ruleExecModInp.ruleId, ruleId, NAME_LEN );
addKeyVal( &ruleExecModInp.condInput, fieldName, fieldValue );
status = rcRuleExecMod( Conn, &ruleExecModInp );
if ( status == CAT_SUCCESS_BUT_WITH_NO_INFO ) {
printf( "No rule found with id %s\n", ruleId );
return status;
}
if ( status < 0 ) {
printError( Conn, status, "rcRuleExecMod" );
}
return status;
}
char *
convertTime( char *inTime ) {
static char myTime[50];
int status;
/* printf("inTime=%s\n", inTime); */
strncpy( myTime, inTime, sizeof( myTime ) );
if ( myTime[10] == '-' ) {
myTime[10] = '.';
}
if ( myTime[13] == '.' ) {
myTime[13] = ':';
}
if ( myTime[16] == '.' ) {
myTime[16] = ':';
}
/* printf("myTime=%s\n", myTime); */
status = checkDateFormat( myTime );
if ( status ) {
printf( "convertTime checkDateFormat error" );
}
/* printf("Converted to local iRODS integer time: %s\n", myTime); */
return myTime;
}
int
main(int argc, char **argv)
{
int status;
rodsArguments_t myRodsArgs;
rodsEnv myEnv;
int i, j, didOne;
char objPath[MAX_NAME_LEN];
int maxCmdTokens=20;
char *cmdToken[20];
int argOffset;
rcComm_t *Conn;
rErrMsg_t errMsg;
char *mySubName;
char *myName;
status = parseCmdLineOpt(argc, argv, "lvVh", 0, &myRodsArgs);
if (status) {
printf("Use -h for help\n");
exit(1);
}
if (myRodsArgs.help==True) {
usage("");
exit(0);
}
argOffset = myRodsArgs.optind;
status = getRodsEnv (&myEnv);
if (status < 0) {
rodsLog (LOG_ERROR, "main: getRodsEnv error. status = %d",
status);
exit (1);
}
strncpy(objPath,myEnv.rodsCwd,MAX_NAME_LEN);
for (i=0;i<maxCmdTokens;i++) {
cmdToken[i]="";
}
j=0;
for (i=argOffset;i<argc;i++) {
cmdToken[j++]=argv[i];
}
Conn = rcConnect (myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 0, &errMsg);
if (Conn == NULL) {
myName = rodsErrorName(errMsg.status, &mySubName);
rodsLog(LOG_ERROR, "rcConnect failure %s (%s) (%d) %s",
myName,
mySubName,
errMsg.status,
errMsg.msg);
exit (2);
}
status = clientLogin(Conn);
if (status != 0) {
rcDisconnect(Conn);
exit (3);
}
if (strcmp(cmdToken[0],"ldt")==0) {
if (*cmdToken[1]=='\0') {
cmdToken[1]=" "; /* just for subsequent checks below */
}
}
if (*cmdToken[1]=='\0') {
usage("");
exit(1);
}
if (*cmdToken[1]=='/') {
rstrcpy(objPath, cmdToken[1], MAX_NAME_LEN);
}
else {
rstrcat(objPath, "/", MAX_NAME_LEN);
rstrcat(objPath, cmdToken[1], MAX_NAME_LEN);
}
didOne=0;
if (strcmp(cmdToken[0],"ls")==0) {
int longOption;
if (myRodsArgs.longOption) longOption=1;
if (myRodsArgs.verbose) longOption=1;
doLs(Conn, objPath, longOption);
didOne=1;
}
if (strcmp(cmdToken[0],"ldt")==0) {
doListDataTypes(Conn);
didOne=1;
}
if (strcmp(cmdToken[0],"mod")==0) {
char theTime[TIME_LEN+20];
if (*cmdToken[2]=='\0') {
usage("");
exit(1);
}
if (strcmp(cmdToken[2],"datatype")==0) {
if (*cmdToken[3]=='\0') {
usage("");
exit(1);
}
status = doModDatatype(Conn, objPath, cmdToken[3]);
didOne=1;
}
else if (strcmp(cmdToken[2],"comment")==0) {
if (*cmdToken[3]=='\0') {
usage("");
exit(1);
}
if (*cmdToken[4]=='\0') {
status = doModComment(Conn, objPath, -1, cmdToken[3]);
}
else {
status = doModComment(Conn, objPath, atoi(cmdToken[3]), cmdToken[4]);
}
didOne=1;
}
else {
rstrcpy(theTime, cmdToken[2], TIME_LEN);
status=0;
if (*cmdToken[2]=='+') {
rstrcpy(theTime, cmdToken[2]+1, TIME_LEN); /* skip the + */
status = checkDateFormat(theTime); /* check and convert the time value */
getOffsetTimeStr(theTime, theTime); /* convert delta format to now + this*/
} else {
status = checkDateFormat(theTime); /* check and convert the time value */
}
if (status==0) {
status = doMod(Conn, objPath, theTime);
didOne=1;
}
else {
printf("Invalid time format input\n");
}
}
}
printErrorStack(Conn->rError);
rcDisconnect(Conn);
if (didOne==0) {
usage("");
exit(1);
}
exit(0);
}
int
fillSubmitConditions (char *action, char *inDelayCondition,
bytesBuf_t *packedReiAndArgBBuf, ruleExecSubmitInp_t *ruleSubmitInfo,
ruleExecInfo_t *rei )
{
int i;
int j = 0;
char kwp[NAME_LEN * 2];
char *t, *s;
char *delayCondition;
delayCondition = strdup(inDelayCondition);
strncpy(ruleSubmitInfo->ruleName, action, META_STR_LEN);
/*
i= copyTaggedValue(delayCondition,"UN", ruleSubmitInfo->userName,NAME_LEN);
if (i != 0 && i != UNMATCHED_KEY_OR_INDEX) return(i);
*/
i= copyTaggedValue(delayCondition,"EA", ruleSubmitInfo->exeAddress,NAME_LEN);
if (i != 0 && i != UNMATCHED_KEY_OR_INDEX){
free(delayCondition); // cppcheck - Memory leak: delayCondition
return(i);
}
i= copyTaggedValue(delayCondition,"ET", ruleSubmitInfo->exeTime,NAME_LEN);
if (i != 0 && i != UNMATCHED_KEY_OR_INDEX) {
free(delayCondition); // cppcheck - Memory leak: delayCondition
return(i);
}
else if (i == 0) {
i = checkDateFormat(ruleSubmitInfo->exeTime);
if (i != 0) {
free(delayCondition); // cppcheck - Memory leak: delayCondition
return(i);
}
}
i= copyTaggedValue(delayCondition,"EF", ruleSubmitInfo->exeFrequency,NAME_LEN);
if (i != 0 && i != UNMATCHED_KEY_OR_INDEX) {
free(delayCondition); // cppcheck - Memory leak: delayCondition
return(i);
}
i= copyTaggedValue(delayCondition,"PRI",ruleSubmitInfo->priority,NAME_LEN);
if (i != 0 && i != UNMATCHED_KEY_OR_INDEX) {
free(delayCondition); // cppcheck - Memory leak: delayCondition
return(i);
}
i= copyTaggedValue(delayCondition,"EET",ruleSubmitInfo->estimateExeTime,NAME_LEN);
if (i != 0 && i != UNMATCHED_KEY_OR_INDEX) {
free(delayCondition); // cppcheck - Memory leak: delayCondition
return(i);
}
i= copyTaggedValue(delayCondition,"NA", ruleSubmitInfo->notificationAddr,NAME_LEN);
if (i != 0 && i != UNMATCHED_KEY_OR_INDEX) {
free(delayCondition); // cppcheck - Memory leak: delayCondition
return(i);
}
i= copyTaggedValue(delayCondition,"PLUSET", kwp,NAME_LEN * 2);
if (i != 0 && i != UNMATCHED_KEY_OR_INDEX) {
free(delayCondition); // cppcheck - Memory leak: delayCondition
return(i);
}
else if (i == 0) {
i = checkDateFormat(kwp);
if (i != 0)
return(i);
getOffsetTimeStr(ruleSubmitInfo->exeTime,kwp);
}
if (i != 0 && i != UNMATCHED_KEY_OR_INDEX) return(i);
i= copyTaggedValue(delayCondition,"KVALPR",kwp,NAME_LEN * 2);
while (i >= 0) {
if ((t = strstr(kwp,"=")) == NULL) {
free(delayCondition);
return(INPUT_ARG_NOT_WELL_FORMED_ERR);
}
*t = '\0';
s = t-1;
while (*s == ' ') s--;
*(s+1) = '\0';
ruleSubmitInfo->condInput.keyWord[j] = strdup(kwp);
t++;
while (*t == ' ') t++;
ruleSubmitInfo->condInput.value[j] = t;
j++;
i= copyTaggedValue(delayCondition,"KWVAL",kwp,NAME_LEN * 2);
}
ruleSubmitInfo->condInput.len = j;
ruleSubmitInfo->packedReiAndArgBBuf = packedReiAndArgBBuf;
if (ruleSubmitInfo->userName == NULL || strlen(ruleSubmitInfo->userName) == 0) {
if (rei->uoic->userName != NULL)
strncpy(ruleSubmitInfo->userName, rei->uoic->userName,NAME_LEN);
else if (rei->rsComm->clientUser.userName != NULL)
strncpy(rei->rsComm->clientUser.userName,rei->uoic->userName,NAME_LEN);
}
free(delayCondition);
return(0);
}
/**
* \fn msiVerifyExpiry (msParam_t* collinp, msParam_t* timeinp, msParam_t* typeinp, msParam_t* bufout, msParam_t* statout, ruleExecInfo_t* rei)
*
* \brief This microservice checks whether files in a collection have expired or not expired.
*
* \deprecated Since 3.0, the integrityChecks module microservices have been reproduced
* using rules. These microservices only handled 256 files per collection.
* The example rules handle an arbitrary number of files.
*
* \module integrityChecks
*
* \since pre-2.1
*
* \author Susan Lindsey
* \date September 2008
*
* \usage See clients/icommands/test/rules3.0/
*
* \param[in] collinp - a STR_MS_T containing the collection's name
* \param[in] timeinp - a STR_MS_T containing a date
* \param[in] typeinp - a STR_MS_T containing one of {EXPIRED or NOTEXPIRED}
* \param[out] bufout - a STR_MS_T containing the output string
* \param[out] statout - the returned status
* \param[in,out] rei - The RuleExecInfo structure that is automatically
* handled by the rule engine. The user does not include rei as a
* parameter in the rule invocation.
*
* \DolVarDependence none
* \DolVarModified none
* \iCatAttrDependence none
* \iCatAttrModified none
* \sideeffect none
*
* \return integer
* \retval rei->status
* \pre none
* \post none
* \sa none
**/
int
msiVerifyExpiry (msParam_t* collinp, msParam_t* timeinp, msParam_t* typeinp, msParam_t* bufout, msParam_t* statout, ruleExecInfo_t* rei)
{
rsComm_t *rsComm;
genQueryInp_t gqin;
genQueryOut_t *gqout = NULL;
char condStr[MAX_NAME_LEN];
char tmpstr[MAX_NAME_LEN];
char* collname;
sqlResult_t *dataName;
sqlResult_t *dataExpiry;
bytesBuf_t* mybuf=NULL;
int i,j,status;
char* inputtime;
char* querytype;
int checkExpiredFlag=0;
char inputtimestr[TIME_LEN];
RE_TEST_MACRO (" Calling msiVerifyExpiry")
/* Sanity check */
if (rei == NULL || rei->rsComm == NULL) {
rodsLog (LOG_ERROR, "msiListFields: input rei or rsComm is NULL");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
rsComm = rei->rsComm;
/* init stuff */
memset (&gqin, 0, sizeof(genQueryInp_t));
gqin.maxRows = MAX_SQL_ROWS;
mybuf = (bytesBuf_t *) malloc (sizeof (bytesBuf_t));
memset (mybuf, 0, sizeof (bytesBuf_t));
gqout = (genQueryOut_t*) malloc (sizeof (genQueryOut_t));
memset (gqout, 0, sizeof (genQueryOut_t));
/* construct an SQL query from the parameter list */
collname = strdup ((char*)collinp->inOutStruct);
inputtime = strdup ((char*)timeinp->inOutStruct);
querytype = strdup ((char*)typeinp->inOutStruct);
/*
We have a couple of rule query possibilities:
1. If 'inputtime' is valid & querytype == EXPIRED then list files which have an expiration date equal or past the input time
2. If 'inputtime' is valid & querytype == NOTEXPIRED then list files which have yet to expire
*/
/* gotta at least have a collection name input */
if (collname==NULL) return (USER_PARAM_TYPE_ERR);
/* convert inputtime to unixtime */
/* SUSAN we should make an option that inputtime = "now" */
rstrcpy (inputtimestr, inputtime, TIME_LEN);
status = checkDateFormat (inputtimestr);
if (status < 0) return (DATE_FORMAT_ERR);
/* now figure out what kind of query to perform */
if (!strcmp(querytype, "EXPIRED")) {
checkExpiredFlag = 1;
} else if (!strcmp(querytype, "NOTEXPIRED")) {
checkExpiredFlag = 0;
} else return (USER_PARAM_TYPE_ERR);
/* this is the info we want returned from the query */
addInxIval (&gqin.selectInp, COL_DATA_NAME, 1);
addInxIval (&gqin.selectInp, COL_D_EXPIRY , 1);
snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
addInxVal (&gqin.sqlCondInp, COL_COLL_NAME, condStr);
j = rsGenQuery (rsComm, &gqin, &gqout);
if (j<0) {
appendToByteBuf (mybuf, "General Query was bad");
} else if (j != CAT_NO_ROWS_FOUND) {
int dataobjexpiry, inputtimeexpiry;
dataName = getSqlResultByInx (gqout, COL_DATA_NAME);
dataExpiry = getSqlResultByInx (gqout, COL_D_EXPIRY);
inputtimeexpiry = atoi (inputtimestr);
for (i=0; i<gqout->rowCnt; i++) {
dataobjexpiry = atoi(&dataExpiry->value[dataExpiry->len*i]);
/* check for expired files */
if (checkExpiredFlag) {
if (dataobjexpiry < inputtimeexpiry) {
sprintf (tmpstr, "Data object:%s\twith Expiration date:%s has expired\n",
&dataName->value[dataName->len *i], &dataExpiry->value[dataExpiry->len *i]);
appendToByteBuf (mybuf, tmpstr);
}
} else {
if (dataobjexpiry >= inputtimeexpiry) {
sprintf (tmpstr, "Data object:%s\twith Expiration date:%s is expiring\n",
&dataName->value[dataName->len *i], &dataExpiry->value[dataExpiry->len *i]);
appendToByteBuf (mybuf, tmpstr);
}
}
}
} else appendToByteBuf (mybuf, "No rows found\n");
fillBufLenInMsParam (bufout, mybuf->len, mybuf);
fillIntInMsParam (statout, rei->status);
return(rei->status);
}
