/* resolveDataObjReplStatus - a dirty copy may be deleted leaving no
* dirty copy. In that case, pick the newest copy and mark it dirty
*/
int
resolveDataObjReplStatus( rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp ) {
int status;
dataObjInfo_t *dataObjInfoHead = NULL;
dataObjInfo_t *newestDataObjInfo = NULL;
dataObjInfo_t *tmpDataObjInfo;
if ( getValByKey( &dataObjUnlinkInp->condInput, RESC_NAME_KW ) == NULL &&
getValByKey( &dataObjUnlinkInp->condInput, REPL_NUM_KW ) == NULL ) {
return 0;
}
status = getDataObjInfo( rsComm, dataObjUnlinkInp,
&dataObjInfoHead, ACCESS_DELETE_OBJECT, 1 );
if ( status < 0 ) {
return status;
}
tmpDataObjInfo = dataObjInfoHead;
while ( tmpDataObjInfo != NULL ) {
if ( tmpDataObjInfo->replStatus == 0 ) {
if ( newestDataObjInfo == NULL ) {
newestDataObjInfo = tmpDataObjInfo;
}
else if ( atoi( tmpDataObjInfo->dataModify ) >
atoi( newestDataObjInfo->dataModify ) ) {
newestDataObjInfo = tmpDataObjInfo;
}
}
else {
newestDataObjInfo = NULL;
break;
}
tmpDataObjInfo = tmpDataObjInfo->next;
}
/* modify the repl status */
if ( newestDataObjInfo != NULL ) {
keyValPair_t regParam;
char tmpStr[MAX_NAME_LEN];
modDataObjMeta_t modDataObjMetaInp;
memset( ®Param, 0, sizeof( regParam ) );
memset( &modDataObjMetaInp, 0, sizeof( modDataObjMetaInp ) );
snprintf( tmpStr, MAX_NAME_LEN, "%d", NEWLY_CREATED_COPY );
addKeyVal( ®Param, REPL_STATUS_KW, tmpStr );
modDataObjMetaInp.dataObjInfo = newestDataObjInfo;
modDataObjMetaInp.regParam = ®Param;
status = rsModDataObjMeta( rsComm, &modDataObjMetaInp );
clearKeyVal( ®Param );
}
freeAllDataObjInfo( dataObjInfoHead );
return status;
}
int
computeHostAddress(rsComm_t *rsComm, char *inStr, rodsHostAddr_t *addr)
{
int status;
dataObjInp_t dataObjInp;
dataObjInfo_t *dataObjInfoHead = NULL;
char *path;
rescGrpInfo_t *rescGrpInfo = NULL;
if (inStr[0] == '@')
path = inStr + 1;
else
path = inStr;
if (path[0] == '/') { /* objpath */
memset (&dataObjInp, 0, sizeof (dataObjInp));
rstrcpy (dataObjInp.objPath, path, MAX_NAME_LEN);
status = getDataObjInfo (rsComm, &dataObjInp, &dataObjInfoHead,
ACCESS_READ_OBJECT, 0);
if (status < 0) {
rodsLog (LOG_ERROR,
"computeHostAddress: getDataObjInfo error for Path %s", path);
return (status);
}
status = sortObjInfoForOpen (rsComm, &dataObjInfoHead, NULL, 0);
if (status < 0) {
rodsLog (LOG_ERROR,
"computeHostAddress: sortObjInfoForOpen error for Path %s", path);
return status;
}
rstrcpy (addr->zoneName, dataObjInfoHead->rescInfo->zoneName, NAME_LEN);
rstrcpy (addr->hostAddr, dataObjInfoHead->rescInfo->rescLoc, LONG_NAME_LEN);
freeAllDataObjInfo (dataObjInfoHead);
}
else { /* it is a logical resource (or group) name */
status = getRescInfo (rsComm, path, NULL, &rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"computeHostAddress: getRescInfo error for Path %s", path);
return (status);
}
status = sortResc(rsComm, &rescGrpInfo, "random");
if (status < 0) {
rodsLog (LOG_ERROR,
"computeHostAddress: sortResc error for Path %s", path);
return status;
}
rstrcpy (addr->zoneName, rescGrpInfo->rescInfo->zoneName, NAME_LEN);
rstrcpy (addr->hostAddr, rescGrpInfo->rescInfo->rescLoc, LONG_NAME_LEN);
freeAllRescGrpInfo (rescGrpInfo);
}
return(0);
}
int
filePathRegRepl (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp, char *filePath,
rescInfo_t *rescInfo)
{
dataObjInfo_t destDataObjInfo, *dataObjInfoHead = NULL;
regReplica_t regReplicaInp;
char *rescGroupName = NULL;
int status;
status = getDataObjInfo (rsComm, phyPathRegInp, &dataObjInfoHead,
ACCESS_READ_OBJECT, 0);
if (status < 0) {
rodsLog (LOG_ERROR,
"filePathRegRepl: getDataObjInfo for %s", phyPathRegInp->objPath);
return (status);
}
status = sortObjInfoForOpen (rsComm, &dataObjInfoHead, NULL, 0);
if (status < 0) return status;
destDataObjInfo = *dataObjInfoHead;
rstrcpy (destDataObjInfo.filePath, filePath, MAX_NAME_LEN);
destDataObjInfo.rescInfo = rescInfo;
rstrcpy (destDataObjInfo.rescName, rescInfo->rescName, NAME_LEN);
if ((rescGroupName = getValByKey (&phyPathRegInp->condInput,
RESC_GROUP_NAME_KW)) != NULL) {
rstrcpy (destDataObjInfo.rescGroupName, rescGroupName, NAME_LEN);
}
memset (®ReplicaInp, 0, sizeof (regReplicaInp));
regReplicaInp.srcDataObjInfo = dataObjInfoHead;
regReplicaInp.destDataObjInfo = &destDataObjInfo;
if (getValByKey (&phyPathRegInp->condInput, SU_CLIENT_USER_KW) != NULL) {
addKeyVal (®ReplicaInp.condInput, SU_CLIENT_USER_KW, "");
addKeyVal (®ReplicaInp.condInput, IRODS_ADMIN_KW, "");
} else if (getValByKey (&phyPathRegInp->condInput,
IRODS_ADMIN_KW) != NULL) {
addKeyVal (®ReplicaInp.condInput, IRODS_ADMIN_KW, "");
}
status = rsRegReplica (rsComm, ®ReplicaInp);
clearKeyVal (®ReplicaInp.condInput);
freeAllDataObjInfo (dataObjInfoHead);
return status;
}
int
specCollSubStat( rsComm_t *rsComm, specColl_t *specColl,
char *subPath, specCollPerm_t specCollPerm, dataObjInfo_t **dataObjInfo ) {
int status;
int objType;
rodsStat_t *rodsStat = NULL;
dataObjInfo_t *myDataObjInfo = NULL;;
if ( dataObjInfo == NULL ) {
return USER__NULL_INPUT_ERR;
}
*dataObjInfo = NULL;
if ( specColl->collClass == MOUNTED_COLL ) {
/* a mount point */
myDataObjInfo = *dataObjInfo = ( dataObjInfo_t * ) malloc( sizeof( dataObjInfo_t ) );
memset( myDataObjInfo, 0, sizeof( dataObjInfo_t ) );
/*status = resolveResc (specColl->resource, &myDataObjInfo->rescInfo);
if (status < 0) {
rodsLog( LOG_ERROR,"specCollSubStat: resolveResc error for %s, status = %d",
specColl->resource, status);
freeDataObjInfo (myDataObjInfo);
*dataObjInfo = NULL;
return status;
}*/
rstrcpy( myDataObjInfo->objPath, subPath, MAX_NAME_LEN );
rstrcpy( myDataObjInfo->subPath, subPath, MAX_NAME_LEN );
rstrcpy( myDataObjInfo->rescName, specColl->resource, NAME_LEN );
rstrcpy( myDataObjInfo->rescHier, specColl->rescHier, MAX_NAME_LEN );
rstrcpy( myDataObjInfo->dataType, "generic", NAME_LEN );
status = getMountedSubPhyPath( specColl->collection,
specColl->phyPath, subPath, myDataObjInfo->filePath );
if ( status < 0 ) {
freeDataObjInfo( myDataObjInfo );
*dataObjInfo = NULL;
return status;
}
replSpecColl( specColl, &myDataObjInfo->specColl );
}
else if ( specColl->collClass == LINKED_COLL ) {
/* a link point */
specCollCache_t *specCollCache = NULL;
char newPath[MAX_NAME_LEN];
specColl_t *curSpecColl;
char *accessStr;
dataObjInp_t myDataObjInp;
rodsObjStat_t *rodsObjStatOut = NULL;
*dataObjInfo = NULL;
curSpecColl = specColl;
status = getMountedSubPhyPath( curSpecColl->collection,
curSpecColl->phyPath, subPath, newPath );
if ( status < 0 ) {
return status;
}
status = resolveLinkedPath( rsComm, newPath, &specCollCache, NULL );
if ( status < 0 ) {
return status;
}
if ( specCollCache != NULL &&
specCollCache->specColl.collClass != LINKED_COLL ) {
status = specCollSubStat( rsComm, &specCollCache->specColl,
newPath, specCollPerm, dataObjInfo );
return status;
}
bzero( &myDataObjInp, sizeof( myDataObjInp ) );
rstrcpy( myDataObjInp.objPath, newPath, MAX_NAME_LEN );
status = collStat( rsComm, &myDataObjInp, &rodsObjStatOut );
if ( status >= 0 && NULL != rodsObjStatOut ) { /* a collection */ // JMC cppcheck - nullptr
myDataObjInfo = *dataObjInfo =
( dataObjInfo_t * ) malloc( sizeof( dataObjInfo_t ) );
memset( myDataObjInfo, 0, sizeof( dataObjInfo_t ) );
replSpecColl( curSpecColl, &myDataObjInfo->specColl );
rstrcpy( myDataObjInfo->objPath, newPath, MAX_NAME_LEN );
myDataObjInfo->dataId = strtoll( rodsObjStatOut->dataId, 0, 0 );
rstrcpy( myDataObjInfo->dataOwnerName, rodsObjStatOut->ownerName, NAME_LEN );
rstrcpy( myDataObjInfo->dataOwnerZone, rodsObjStatOut->ownerZone, NAME_LEN );
rstrcpy( myDataObjInfo->dataCreate, rodsObjStatOut->createTime, TIME_LEN );
rstrcpy( myDataObjInfo->dataModify, rodsObjStatOut->modifyTime, TIME_LEN );
freeRodsObjStat( rodsObjStatOut );
return COLL_OBJ_T;
}
freeRodsObjStat( rodsObjStatOut );
/* data object */
if ( specCollPerm == READ_COLL_PERM ) {
accessStr = ACCESS_READ_OBJECT;
}
else if ( specCollPerm == WRITE_COLL_PERM ) {
accessStr = ACCESS_DELETE_OBJECT;
}
else {
accessStr = NULL;
}
status = getDataObjInfo( rsComm, &myDataObjInp, dataObjInfo,
accessStr, 0 );
if ( status < 0 ) {
myDataObjInfo = *dataObjInfo =
( dataObjInfo_t * ) malloc( sizeof( dataObjInfo_t ) );
memset( myDataObjInfo, 0, sizeof( dataObjInfo_t ) );
replSpecColl( curSpecColl, &myDataObjInfo->specColl );
rstrcpy( myDataObjInfo->objPath, newPath, MAX_NAME_LEN );
rodsLog( LOG_DEBUG,
"specCollSubStat: getDataObjInfo error for %s, status = %d",
newPath, status );
return status;
}
else {
replSpecColl( curSpecColl, &( *dataObjInfo )->specColl );
return DATA_OBJ_T;
}
}
else if ( getStructFileType( specColl ) >= 0 ) {
/* bundle */
dataObjInp_t myDataObjInp;
dataObjInfo_t *tmpDataObjInfo;
bzero( &myDataObjInp, sizeof( myDataObjInp ) );
rstrcpy( myDataObjInp.objPath, specColl->objPath, MAX_NAME_LEN );
// add the resource hierarchy to the condInput of the inp
addKeyVal( &myDataObjInp.condInput, RESC_HIER_STR_KW, specColl->rescHier );
status = getDataObjInfo( rsComm, &myDataObjInp, dataObjInfo, NULL, 1 );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"specCollSubStat: getDataObjInfo error for %s, status = %d",
myDataObjInp.objPath, status );
*dataObjInfo = NULL;
return status;
}
/* screen out any stale copies */
status = sortObjInfoForOpen( dataObjInfo, &myDataObjInp.condInput, 0 );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"specCollSubStat: sortObjInfoForOpen error for %s. status = %d",
myDataObjInp.objPath, status );
return status;
}
if ( strlen( specColl->resource ) > 0 ) {
if ( requeDataObjInfoByResc( dataObjInfo, specColl->resource,
0, 1 ) >= 0 ) {
if ( strcmp( specColl->resource,
( *dataObjInfo )->rescName ) != 0 ) {
rodsLog( LOG_ERROR,
"specCollSubStat: %s in %s does not match cache resc %s",
myDataObjInp.objPath, ( *dataObjInfo )->rescName,
specColl->resource );
freeAllDataObjInfo( *dataObjInfo );
*dataObjInfo = NULL;
return SYS_CACHE_STRUCT_FILE_RESC_ERR;
}
}
else {
rodsLog( LOG_ERROR,
"specCollSubStat: requeDataObjInfoByResc %s, resc %s error",
myDataObjInp.objPath, specColl->resource );
freeAllDataObjInfo( *dataObjInfo );
*dataObjInfo = NULL;
return SYS_CACHE_STRUCT_FILE_RESC_ERR;
}
}
/* free all the other dataObjInfo */
if ( ( *dataObjInfo )->next != NULL ) {
freeAllDataObjInfo( ( *dataObjInfo )->next );
( *dataObjInfo )->next = NULL;
}
/* fill in DataObjInfo */
tmpDataObjInfo = *dataObjInfo;
replSpecColl( specColl, &tmpDataObjInfo->specColl );
rstrcpy( specColl->resource, tmpDataObjInfo->rescName, NAME_LEN );
rstrcpy( specColl->rescHier, tmpDataObjInfo->rescHier, MAX_NAME_LEN );
rstrcpy( specColl->phyPath, tmpDataObjInfo->filePath, MAX_NAME_LEN );
rstrcpy( tmpDataObjInfo->subPath, subPath, MAX_NAME_LEN );
specColl->replNum = tmpDataObjInfo->replNum;
if ( strcmp( ( *dataObjInfo )->subPath, specColl->collection ) == 0 ) {
/* no need to go down */
return COLL_OBJ_T;
}
}
else {
rodsLog( LOG_ERROR,
"specCollSubStat: Unknown specColl collClass = %d",
specColl->collClass );
return SYS_UNKNOWN_SPEC_COLL_CLASS;
}
status = l3Stat( rsComm, *dataObjInfo, &rodsStat );
if ( status < 0 ) {
return status;
}
if ( rodsStat->st_ctim != 0 ) {
snprintf( ( *dataObjInfo )->dataCreate, TIME_LEN, "%d", rodsStat->st_ctim );
snprintf( ( *dataObjInfo )->dataModify, TIME_LEN, "%d", rodsStat->st_mtim );
}
if ( rodsStat->st_mode & S_IFDIR ) {
objType = COLL_OBJ_T;
}
else {
objType = DATA_OBJ_T;
( *dataObjInfo )->dataSize = rodsStat->st_size;
}
free( rodsStat );
return objType;
}
int
rsDataObjPhymv( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
transferStat_t **transStat ) {
int status = 0;
dataObjInfo_t *dataObjInfoHead = NULL;
dataObjInfo_t *oldDataObjInfoHead = NULL;
rescGrpInfo_t *myRescGrpInfo = NULL;
ruleExecInfo_t rei;
int multiCopyFlag = 0;
char *accessPerm = NULL;
int remoteFlag = 0;
rodsServerHost_t *rodsServerHost = NULL;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput );
remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost,
REMOTE_OPEN );
if ( remoteFlag < 0 ) {
return remoteFlag;
}
else if ( remoteFlag == REMOTE_HOST ) {
status = _rcDataObjPhymv( rodsServerHost->conn, dataObjInp,
transStat );
return status;
}
// =-=-=-=-=-=-=-
// determine hierarchy string
if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
std::string hier;
irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION, rsComm,
dataObjInp, hier );
if ( !ret.ok() ) {
std::stringstream msg;
msg << __FUNCTION__;
msg << " :: failed in irods::resolve_resource_hierarchy for [";
msg << dataObjInp->objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
} // if keyword
*transStat = ( transferStat_t* )malloc( sizeof( transferStat_t ) );
memset( *transStat, 0, sizeof( transferStat_t ) );
if ( getValByKey( &dataObjInp->condInput, ADMIN_KW ) != NULL ) {
if ( rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH ) {
return CAT_INSUFFICIENT_PRIVILEGE_LEVEL;
}
accessPerm = NULL;
}
else {
accessPerm = ACCESS_DELETE_OBJECT;
}
/* query rcat for resource info and sort it */
status = getRescGrpForCreate( rsComm, dataObjInp, &myRescGrpInfo );
if ( status < 0 ) {
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
return status;
}
initReiWithDataObjInp( &rei, rsComm, dataObjInp );
status = applyRule( "acSetMultiReplPerResc", NULL, &rei, NO_SAVE_REI );
if ( strcmp( rei.statusStr, MULTI_COPIES_PER_RESC ) == 0 ) {
multiCopyFlag = 1;
}
else {
multiCopyFlag = 0;
}
/* query rcat for dataObjInfo and sort it */
status = getDataObjInfo( rsComm, dataObjInp, &dataObjInfoHead,
accessPerm, 1 );
if ( status < 0 ) {
rodsLog( LOG_NOTICE,
"rsDataObjPhymv: getDataObjInfo for %s", dataObjInp->objPath );
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
return status;
}
status = resolveInfoForPhymv( &dataObjInfoHead, &oldDataObjInfoHead, &myRescGrpInfo, &dataObjInp->condInput, multiCopyFlag );
if ( status < 0 ) {
freeAllDataObjInfo( dataObjInfoHead );
freeAllDataObjInfo( oldDataObjInfoHead );
if ( myRescGrpInfo ) {
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
}
if ( status == CAT_NO_ROWS_FOUND ) {
return 0;
}
else {
return status;
}
}
status = _rsDataObjPhymv( rsComm, dataObjInp, dataObjInfoHead,
myRescGrpInfo, *transStat, multiCopyFlag );
freeAllDataObjInfo( dataObjInfoHead );
freeAllDataObjInfo( oldDataObjInfoHead );
if ( myRescGrpInfo ) {
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
}
return status;
}
int
rsDataObjPhymv (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
transferStat_t **transStat)
{
int status;
dataObjInfo_t *dataObjInfoHead = NULL;
dataObjInfo_t *oldDataObjInfoHead = NULL;
rescGrpInfo_t *myRescGrpInfo = NULL;
ruleExecInfo_t rei;
int multiCopyFlag;
char *accessPerm;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput);
remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
REMOTE_OPEN);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == REMOTE_HOST) {
status = _rcDataObjPhymv (rodsServerHost->conn, dataObjInp,
transStat);
return status;
}
*transStat = (transferStat_t*)malloc (sizeof (transferStat_t));
memset (*transStat, 0, sizeof (transferStat_t));
if (getValByKey (&dataObjInp->condInput, IRODS_ADMIN_KW) != NULL) {
if (rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) {
return (CAT_INSUFFICIENT_PRIVILEGE_LEVEL);
}
accessPerm = NULL;
} else {
accessPerm = ACCESS_DELETE_OBJECT;
}
/* query rcat for resource info and sort it */
status = getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo);
if (status < 0) return status;
initReiWithDataObjInp (&rei, rsComm, dataObjInp);
status = applyRule ("acSetMultiReplPerResc", NULL, &rei, NO_SAVE_REI);
if (strcmp (rei.statusStr, MULTI_COPIES_PER_RESC) == 0) {
multiCopyFlag = 1;
} else {
multiCopyFlag = 0;
}
/* query rcat for dataObjInfo and sort it */
status = getDataObjInfo (rsComm, dataObjInp, &dataObjInfoHead,
accessPerm, 1);
if (status < 0) {
rodsLog (LOG_NOTICE,
"rsDataObjPhymv: getDataObjInfo for %s", dataObjInp->objPath);
return (status);
}
status = resolveInfoForPhymv (&dataObjInfoHead, &oldDataObjInfoHead,
&myRescGrpInfo, &dataObjInp->condInput, multiCopyFlag);
if (status < 0) {
freeAllDataObjInfo (dataObjInfoHead);
freeAllDataObjInfo (oldDataObjInfoHead);
freeAllRescGrpInfo (myRescGrpInfo);
if (status == CAT_NO_ROWS_FOUND) {
return (0);
} else {
return (status);
}
}
status = _rsDataObjPhymv (rsComm, dataObjInp, dataObjInfoHead,
myRescGrpInfo, *transStat, multiCopyFlag);
freeAllDataObjInfo (dataObjInfoHead);
freeAllDataObjInfo (oldDataObjInfoHead);
freeAllRescGrpInfo (myRescGrpInfo);
return (status);
}
int
rsExecCmd (rsComm_t *rsComm, execCmd_t *execCmdInp, execCmdOut_t **execCmdOut)
{
int status;
dataObjInfo_t *dataObjInfoHead = NULL;
rodsServerHost_t *rodsServerHost;
int remoteFlag;
rodsHostAddr_t addr;
/* some sanity check on the cmd path */
if (strchr (execCmdInp->cmd, '/') != NULL) {
rodsLog (LOG_ERROR,
"rsExecCmd: bad cmd path %s", execCmdInp->cmd);
return (BAD_EXEC_CMD_PATH);
}
memset (&addr, 0, sizeof (addr));
if (*execCmdInp->hintPath != '\0') {
dataObjInp_t dataObjInp;
memset (&dataObjInp, 0, sizeof (dataObjInp));
rstrcpy (dataObjInp.objPath, execCmdInp->hintPath, MAX_NAME_LEN);
status = getDataObjInfo (rsComm, &dataObjInp, &dataObjInfoHead,
ACCESS_READ_OBJECT, 0);
if (status < 0) {
rodsLog (LOG_ERROR,
"rsExecCmd: getDataObjInfo error for hintPath %s",
execCmdInp->hintPath);
return (status);
}
status = sortObjInfoForOpen (rsComm, &dataObjInfoHead,
&execCmdInp->condInput, 0);
if (status < 0) return status;
if (execCmdInp->addPathToArgv > 0) {
char tmpArgv[LONG_NAME_LEN];
rstrcpy (tmpArgv, execCmdInp->cmdArgv, HUGE_NAME_LEN);
snprintf (execCmdInp->cmdArgv, HUGE_NAME_LEN, "%s %s",
dataObjInfoHead->filePath, tmpArgv);
}
rstrcpy (addr.zoneName, dataObjInfoHead->rescInfo->zoneName,
NAME_LEN);
rstrcpy (addr.hostAddr, dataObjInfoHead->rescInfo->rescLoc,
LONG_NAME_LEN);
/* just in case we have to do it remote */
*execCmdInp->hintPath = '\0'; /* no need for hint */
rstrcpy (execCmdInp->execAddr, dataObjInfoHead->rescInfo->rescLoc,
LONG_NAME_LEN);
freeAllDataObjInfo (dataObjInfoHead);
remoteFlag = resolveHost (&addr, &rodsServerHost);
} else if (*execCmdInp->execAddr != '\0') {
rstrcpy (addr.hostAddr, execCmdInp->execAddr, LONG_NAME_LEN);
remoteFlag = resolveHost (&addr, &rodsServerHost);
} else {
rodsServerHost = LocalServerHost;
remoteFlag = LOCAL_HOST;
}
if (remoteFlag == LOCAL_HOST) {
status = _rsExecCmd (rsComm, execCmdInp, execCmdOut);
} else if (remoteFlag == REMOTE_HOST) {
status = remoteExecCmd (rsComm, execCmdInp, execCmdOut,
rodsServerHost);
} else {
rodsLog (LOG_NOTICE,
"rsFileOpenByHost: resolveHost of %s error, status = %d",
addr.hostAddr, remoteFlag);
status = SYS_UNRECOGNIZED_REMOTE_FLAG;
}
return (status);
}
int
rsMvDataObjToTrash (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
dataObjInfo_t **dataObjInfoHead)
{
int status;
char trashPath[MAX_NAME_LEN];
dataObjCopyInp_t dataObjRenameInp;
if (strstr ((*dataObjInfoHead)->dataType, BUNDLE_STR) != NULL) {
return SYS_CANT_MV_BUNDLE_DATA_TO_TRASH;
}
if (getValByKey (&dataObjInp->condInput, DATA_ACCESS_KW) == NULL) {
addKeyVal (&dataObjInp->condInput, DATA_ACCESS_KW,
ACCESS_DELETE_OBJECT);
}
status = getDataObjInfo (rsComm, dataObjInp, dataObjInfoHead,
ACCESS_DELETE_OBJECT, 0);
if (status < 0) {
rodsLog (LOG_NOTICE,
"rsMvDataObjToTrash: getDataObjInfo error for %s. status = %d",
dataObjInp->objPath, status);
return (status);
}
status = chkPreProcDeleteRule (rsComm, dataObjInp, *dataObjInfoHead);
if (status < 0) return status;
#if 0 /* done in chkPreProcDeleteRule */
initReiWithDataObjInp (&rei, rsComm, dataObjInp);
rei.doi = *dataObjInfoHead;
status = applyRule ("acDataDeletePolicy", NULL, &rei, NO_SAVE_REI);
if (status < 0 && status != NO_MORE_RULES_ERR &&
status != SYS_DELETE_DISALLOWED) {
rodsLog (LOG_NOTICE,
"rsMvDataObjToTrash: acDataDeletePolicy error for %s. status = %d",
dataObjInp->objPath, status);
return (status);
}
if (rei.status == SYS_DELETE_DISALLOWED) {
rodsLog (LOG_NOTICE,
"rsMvDataObjToTrash:disallowed for %s via DataDeletePolicy,status=%d",
dataObjInp->objPath, rei.status);
return (rei.status);
}
#endif
status = rsMkTrashPath (rsComm, dataObjInp->objPath, trashPath);
if (status < 0) {
return (status);
}
memset (&dataObjRenameInp, 0, sizeof (dataObjRenameInp));
dataObjRenameInp.srcDataObjInp.oprType =
dataObjRenameInp.destDataObjInp.oprType = RENAME_DATA_OBJ;
rstrcpy (dataObjRenameInp.destDataObjInp.objPath, trashPath, MAX_NAME_LEN);
rstrcpy (dataObjRenameInp.srcDataObjInp.objPath, dataObjInp->objPath,
MAX_NAME_LEN);
status = rsDataObjRename (rsComm, &dataObjRenameInp);
while (status == CAT_NAME_EXISTS_AS_DATAOBJ ||
status == CAT_NAME_EXISTS_AS_COLLECTION ||
status == SYS_PHY_PATH_INUSE ||
getErrno (status) == EISDIR) {
appendRandomToPath (dataObjRenameInp.destDataObjInp.objPath);
status = rsDataObjRename (rsComm, &dataObjRenameInp);
#if 0
if (status1 < 0) {
rodsLog (LOG_ERROR,
"rsMvDataObjToTrash: rsDataObjRename error for %s",
dataObjRenameInp.destDataObjInp.objPath);
} else {
status = 0;
}
#endif
}
if (status < 0) {
rodsLog (LOG_ERROR,
"rsMvDataObjToTrash: rcDataObjRename error for %s, status = %d",
dataObjRenameInp.destDataObjInp.objPath, status);
return (status);
}
return (status);
}
static int process_single_obj( rsComm_t *conn, char *parColl, char *fileName,
int required_num_replicas, char *grpRescForReplication, char *emailToNotify ) {
genQueryInp_t genQueryInp;
int i;
genQueryOut_t *genQueryOut = NULL;
sqlResult_t *replNumStruct, *rescStruct, *dataPathStruct, *chkSumStruct;
char *replNum, *rescName, *dataPathName, *chkSum;
int t;
int i1a[10];
int i1b[10];
int i2a[10];
char *condVal[2];
char v1[200], v2[200];
char vault_path[2048];
char *chksum_str = NULL;
dataObjInp_t myDataObjInp;
dataObjInfo_t *myDataObjInfo = NULL;
unregDataObj_t myUnregDataObjInp;
transferStat_t *transStat = NULL;
ReplicaCheckStatusStruct *pReplicaStatus;
int nReplicas;
char tmpstr[1024];
int at_least_one_copy_is_good = 0;
int newN;
int rn;
int validKwFlags;
char *outBadKeyWd;
msParam_t msGrpRescStr; /* it can be a single resc name or a paired values. */
/* fprintf(stderr,"msiAutoReplicateService():process_single_obj()\n"); */
memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );
i1a[0] = COL_DATA_REPL_NUM;
i1b[0] = 0;
i1a[1] = COL_D_RESC_NAME;
i1b[1] = 0;
i1a[2] = COL_D_RESC_GROUP_NAME;
i1b[2] = 0;
i1a[3] = COL_D_DATA_PATH;
i1b[3] = 0;
i1a[4] = COL_D_DATA_CHECKSUM;
i1b[4] = 0;
genQueryInp.selectInp.inx = i1a;
genQueryInp.selectInp.value = i1b;
genQueryInp.selectInp.len = 5;
i2a[0] = COL_COLL_NAME;
i2a[1] = COL_DATA_NAME;
genQueryInp.sqlCondInp.inx = i2a;
sprintf( v1, "='%s'", parColl );
condVal[0] = v1;
sprintf( v2, "='%s'", fileName );
condVal[1] = v2;
genQueryInp.sqlCondInp.value = condVal;
genQueryInp.sqlCondInp.len = 2;
genQueryInp.maxRows = 10;
genQueryInp.continueInx = 0;
t = rsGenQuery( conn, &genQueryInp, &genQueryOut );
if ( t < 0 ) {
rodsLog( LOG_NOTICE, "msiAutoReplicateService():process_single_obj(): rsGenQuery failed errocode=%d", t );
if ( t == CAT_NO_ROWS_FOUND ) { /* no data is found */
return 0;
}
return( t );
}
if ( genQueryOut->rowCnt <= 0 ) {
rodsLog( LOG_ERROR, "msiAutoReplicateService():process_single_obj(): return 0 record from calling rsGenQuery() for objid=%s/%s", parColl, fileName );
return 0;
}
nReplicas = genQueryOut->rowCnt;
pReplicaStatus = ( ReplicaCheckStatusStruct * )calloc( nReplicas, sizeof( ReplicaCheckStatusStruct ) );
for ( i = 0; i < nReplicas; i++ ) {
pReplicaStatus[i].registered = 0;
pReplicaStatus[i].checksum[0] = '\0';
}
for ( i = 0; i < genQueryOut->rowCnt; i++ ) {
replNumStruct = getSqlResultByInx( genQueryOut, COL_DATA_REPL_NUM );
replNum = &replNumStruct->value[replNumStruct->len * i];
pReplicaStatus[i].repl_num = atoi( replNum );
rescStruct = getSqlResultByInx( genQueryOut, COL_D_RESC_NAME );
rescName = &rescStruct->value[rescStruct->len * i];
getSqlResultByInx( genQueryOut, COL_D_RESC_GROUP_NAME );
dataPathStruct = getSqlResultByInx( genQueryOut, COL_D_DATA_PATH );
dataPathName = &dataPathStruct->value[dataPathStruct->len * i];
chkSumStruct = getSqlResultByInx( genQueryOut, COL_D_DATA_CHECKSUM );
chkSum = &chkSumStruct->value[chkSumStruct->len * i];
vault_path[0] = '\0';
t = get_resource_path( conn, rescName, vault_path );
if ( t < 0 ) {
rodsLog( LOG_NOTICE, "msiAutoReplicateService():process_single_obj():get_resource_path failed, status=%d", t );
free( pReplicaStatus ); // JMc cppcheck - leak
return t;
}
if ( strncmp( dataPathName, vault_path, strlen( vault_path ) ) != 0 ) {
/* fprintf(stderr,"AB1-> %s/%s, v=%s, is a registered copy.\n", parColl,fileName, replNum); */
pReplicaStatus[i].registered = 1;
}
else {
pReplicaStatus[i].registered = 0;
}
if ( ( chkSum != NULL ) && ( strlen( chkSum ) > 0 ) ) {
strcpy( pReplicaStatus[i].checksum, chkSum );
}
}
freeGenQueryOut( &genQueryOut );
/* check replica status */
at_least_one_copy_is_good = 0;
for ( i = 0; i < nReplicas; i++ ) {
/* check the file existence first */
memset( &myDataObjInp, 0, sizeof( dataObjInp_t ) );
snprintf( myDataObjInp.objPath, MAX_NAME_LEN, "%s/%s", parColl, fileName );
myDataObjInp.openFlags = O_RDONLY;
sprintf( tmpstr, "%d", pReplicaStatus[i].repl_num );
addKeyVal( &myDataObjInp.condInput, REPL_NUM_KW, tmpstr );
rn = pReplicaStatus[i].repl_num;
t = rsDataObjOpen( conn, &myDataObjInp );
if ( t < 0 ) {
/* fprintf(stderr,"%d. %s/%s, %d failed to open and has checksum status=%d\n", i, parColl, fileName, rn, t); */
if ( t == SYS_OUT_OF_FILE_DESC ) {
free( pReplicaStatus ); // JMc cppcheck - leak
return t;
}
else {
pReplicaStatus[i].chksum_status = t;
}
}
else {
openedDataObjInp_t myDataObjCloseInp;
memset( &myDataObjCloseInp, 0, sizeof( openedDataObjInp_t ) );
myDataObjCloseInp.l1descInx = t;
t = rsDataObjClose( conn, &myDataObjCloseInp );
chksum_str = NULL;
/* compute checksum rsDataObjChksum() */
memset( &myDataObjInp, 0, sizeof( dataObjInp_t ) );
sprintf( myDataObjInp.objPath, "%s/%s", parColl, fileName );
addKeyVal( &myDataObjInp.condInput, FORCE_CHKSUM_KW, "" );
sprintf( tmpstr, "%d", pReplicaStatus[i].repl_num );
addKeyVal( &myDataObjInp.condInput, REPL_NUM_KW, tmpstr );
t = rsDataObjChksum( conn, &myDataObjInp, &chksum_str );
pReplicaStatus[i].chksum_status = t; /* t == USER_CHKSUM_MISMATCH means a bad copy */
/* fprintf(stderr,"%d. %s/%s, %d has checksum status=%d\n", i, parColl, fileName, rn, t); */
if ( t >= 0 ) {
if ( strlen( pReplicaStatus[i].checksum ) > 0 ) {
if ( strcmp( pReplicaStatus[i].checksum, chksum_str ) != 0 ) { /* mismatch */
pReplicaStatus[i].chksum_status = USER_CHKSUM_MISMATCH;
}
else {
at_least_one_copy_is_good = 1;
}
}
else {
at_least_one_copy_is_good = 1;
}
}
}
}
/* if there is none good copies left. In some casee, the checksum failed due
to the fact that the server is down. We leave this case to be taken care of next time. */
if ( at_least_one_copy_is_good == 0 ) {
rodsLog( LOG_ERROR, "msiAutoReplicateService():process_single_obj(): Obj='%s/%s': Warning: The system detects that all copies might be corrupted.", parColl, fileName );
#ifndef windows_platform
if ( ( emailToNotify != NULL ) && ( strlen( emailToNotify ) > 0 ) ) {
char msg_sub[1024], msg_body[1024];
strcpy( msg_sub, "iRODS msiAutoReplicateService() error" );
sprintf( msg_body, "msiAutoReplicateService():process_single_obj(): Obj='%s/%s': at least one storage server is down or all copies are corrupted.",
parColl, fileName );
UnixSendEmail( emailToNotify, msg_sub, msg_body );
}
#endif
free( pReplicaStatus ); // JMc cppcheck - leak
return 0;
}
/* since we have at least one copy is good. We delete those bad copies (USER_CHKSUM_MISMATCH). */
newN = nReplicas;
for ( i = 0; i < nReplicas; i++ ) {
memset( &myDataObjInp, 0, sizeof( dataObjInp_t ) );
sprintf( myDataObjInp.objPath, "%s/%s", parColl, fileName );
sprintf( tmpstr, "%d", pReplicaStatus[i].repl_num );
addKeyVal( &myDataObjInp.condInput, REPL_NUM_KW, tmpstr );
rn = pReplicaStatus[i].repl_num;
if ( pReplicaStatus[i].registered == 1 ) {
/* here is the catch. iRODS. */
int adchksum;
/* fprintf(stderr,"CD->%s/%s, v=%d, is a registered copy.\n", parColl, fileName, rn); */
adchksum = ( ( int )( pReplicaStatus[i].chksum_status / 1000 ) ) * 1000;
if ( ( pReplicaStatus[i].chksum_status == USER_CHKSUM_MISMATCH ) || ( pReplicaStatus[i].chksum_status == UNIX_FILE_OPEN_ERR ) || ( adchksum == UNIX_FILE_OPEN_ERR ) )
/* USER_CHKSUM_MISMATCH -> indicates the registered file is changed.
* UNIX_FILE_OPEN_ERR --> indicates the registered file is removed by original owner.
* -510002 is transformed from UNIX open error.
*/
{
rodsLog( LOG_NOTICE, "msiAutoReplicateService():process_single_obj(): registered copy will be removed: %s, repl=%d", myDataObjInp.objPath, rn );
t = getDataObjInfo( conn, &myDataObjInp, &myDataObjInfo, NULL, 0 );
if ( t >= 0 ) {
myUnregDataObjInp.dataObjInfo = myDataObjInfo;
myUnregDataObjInp.condInput = &myDataObjInp.condInput;
t = rsUnregDataObj( conn, &myUnregDataObjInp );
if ( t >= 0 ) {
newN = newN - 1;
}
else {
rodsLog( LOG_ERROR, "msiAutoReplicateService():rsUnregDataObj(): failed for %s/%s:%d. erStat=%d", parColl, fileName, rn, t );
return t;
}
}
else {
rodsLog( LOG_ERROR, "msiAutoReplicateService():getDataObjInfo(): failed for %s/%s:%d. erStat=%d", parColl, fileName, rn, t );
return t;
}
}
else {
rodsLog( LOG_ERROR, "%s:%d, the registered copy has errored checksum status=%d.", myDataObjInp.objPath, rn, pReplicaStatus[i].chksum_status );
return t;
}
}
else { /* the data file is in vault */
if ( pReplicaStatus[i].chksum_status == USER_CHKSUM_MISMATCH ) {
t = rsDataObjUnlink( conn, &myDataObjInp );
if ( t >= 0 ) {
newN = newN - 1;
}
else {
rodsLog( LOG_ERROR, "msiAutoReplicateService():rsDataObjUnlink() for %s:%d failed. errStat=%d", myDataObjInp.objPath, rn, t );
free( pReplicaStatus ); // JMc cppcheck - leak
return t;
}
}
}
}
fillStrInMsParam( &msGrpRescStr, grpRescForReplication );
/* make necessary copies based on the required number of copies */
if ( newN < required_num_replicas ) {
rodsLog( LOG_NOTICE, "msiAutoReplicateService():process_single_obj(): making necessary %d copies as required.", ( required_num_replicas - newN ) );
for ( i = 0; i < ( required_num_replicas - newN ); i++ ) {
memset( &myDataObjInp, 0, sizeof( dataObjInp_t ) );
snprintf( myDataObjInp.objPath, MAX_NAME_LEN, "%s/%s", parColl, fileName );
/* addKeyVal(&myDataObjInp.condInput, DEST_RESC_NAME_KW, grpRescForReplication); */
validKwFlags = OBJ_PATH_FLAG | DEST_RESC_NAME_FLAG | NUM_THREADS_FLAG |
BACKUP_RESC_NAME_FLAG | RESC_NAME_FLAG | UPDATE_REPL_FLAG |
REPL_NUM_FLAG | ALL_FLAG | ADMIN_FLAG | VERIFY_CHKSUM_FLAG |
RBUDP_TRANSFER_FLAG | RBUDP_SEND_RATE_FLAG | RBUDP_PACK_SIZE_FLAG;
t = parseMsKeyValStrForDataObjInp( &msGrpRescStr, &myDataObjInp, DEST_RESC_NAME_KW, validKwFlags, &outBadKeyWd );
if ( t < 0 ) {
if ( outBadKeyWd != NULL ) {
rodsLog( LOG_ERROR, "msiAutoReplicateService():rsDataObjRepl(): input keyWd - %s error. status = %d", outBadKeyWd, t );
free( outBadKeyWd );
}
else {
rodsLog( LOG_ERROR, "msiAutoReplicateService():rsDataObjRepl(): input msKeyValStr error. status = %d", t );
}
free( pReplicaStatus ); // JMc cppcheck - leak
return t;
}
t = rsDataObjRepl( conn, &myDataObjInp, &transStat );
if ( t < 0 ) {
rodsLog( LOG_ERROR, "msiAutoReplicateService():rsDataObjRepl() failed for %s/%s:%d into '%s'. err code=%d.", parColl, fileName, rn, grpRescForReplication, t );
repl_storage_error = 1;
free( pReplicaStatus ); // JMc cppcheck - leak
return t;
}
if ( transStat != NULL ) {
free( transStat );
}
}
}
free( pReplicaStatus ); // JMC cppcheck - leak
return 0;
}
int
rsMvDataObjToTrash( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
dataObjInfo_t **dataObjInfoHead ) {
int status;
char trashPath[MAX_NAME_LEN];
dataObjCopyInp_t dataObjRenameInp;
if ( strstr( ( *dataObjInfoHead )->dataType, BUNDLE_STR ) != NULL ) { // JMC - backport 4658
return SYS_CANT_MV_BUNDLE_DATA_TO_TRASH;
}
if ( getValByKey( &dataObjInp->condInput, DATA_ACCESS_KW ) == NULL ) {
addKeyVal( &dataObjInp->condInput, DATA_ACCESS_KW,
ACCESS_DELETE_OBJECT );
}
status = getDataObjInfo( rsComm, dataObjInp, dataObjInfoHead,
ACCESS_DELETE_OBJECT, 0 );
if ( status < 0 ) {
rodsLog( LOG_NOTICE,
"rsMvDataObjToTrash: getDataObjInfo error for %s. status = %d",
dataObjInp->objPath, status );
return status;
}
status = chkPreProcDeleteRule( rsComm, dataObjInp, *dataObjInfoHead );
if ( status < 0 ) {
return status;
}
status = rsMkTrashPath( rsComm, dataObjInp->objPath, trashPath );
if ( status < 0 ) {
return status;
}
memset( &dataObjRenameInp, 0, sizeof( dataObjRenameInp ) );
dataObjRenameInp.srcDataObjInp.oprType =
dataObjRenameInp.destDataObjInp.oprType = RENAME_DATA_OBJ;
rstrcpy( dataObjRenameInp.destDataObjInp.objPath, trashPath, MAX_NAME_LEN );
rstrcpy( dataObjRenameInp.srcDataObjInp.objPath, dataObjInp->objPath,
MAX_NAME_LEN );
status = rsDataObjRename( rsComm, &dataObjRenameInp );
while ( status == CAT_NAME_EXISTS_AS_DATAOBJ ||
status == CAT_NAME_EXISTS_AS_COLLECTION ||
status == SYS_PHY_PATH_INUSE ||
getErrno( status ) == EISDIR ) {
appendRandomToPath( dataObjRenameInp.destDataObjInp.objPath );
status = rsDataObjRename( rsComm, &dataObjRenameInp );
}
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"rsMvDataObjToTrash: rcDataObjRename error for %s, status = %d",
dataObjRenameInp.destDataObjInp.objPath, status );
return status;
}
return status;
}
