int chkPreProcDeleteRule (rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp, dataObjInfo_t *dataObjInfoHead) { dataObjInfo_t *tmpDataObjInfo; ruleExecInfo_t rei; int status = 0; initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp); tmpDataObjInfo = dataObjInfoHead; while (tmpDataObjInfo != NULL) { /* have to go through the loop to test each copy (resource). */ rei.doi = tmpDataObjInfo; status = applyRule ("acDataDeletePolicy", NULL, &rei, NO_SAVE_REI); if (status < 0 && status != NO_MORE_RULES_ERR && status != SYS_DELETE_DISALLOWED) { rodsLog (LOG_ERROR, "chkPreProcDeleteRule: acDataDeletePolicy err for %s. stat = %d", dataObjUnlinkInp->objPath, status); return (status); } if (rei.status == SYS_DELETE_DISALLOWED) { rodsLog (LOG_ERROR, "chkPreProcDeleteRule:acDataDeletePolicy disallowed delete of %s", dataObjUnlinkInp->objPath); return (rei.status); } tmpDataObjInfo = tmpDataObjInfo->next; } return status; }
int applyPreprocRuleForOpen( rsComm_t *rsComm, dataObjInp_t *dataObjInp, dataObjInfo_t **dataObjInfoHead ) { int status; ruleExecInfo_t rei; initReiWithDataObjInp( &rei, rsComm, dataObjInp ); rei.doi = *dataObjInfoHead; // make resource properties available as rule session variables irods::get_resc_properties_as_kvp(rei.doi->rescHier, rei.condInputData); status = applyRule( "acPreprocForDataObjOpen", NULL, &rei, NO_SAVE_REI ); clearKeyVal(rei.condInputData); free(rei.condInputData); if ( status < 0 ) { if ( rei.status < 0 ) { status = rei.status; } rodsLog( LOG_ERROR, "applyPreprocRuleForOpen:acPreprocForDataObjOpen error for %s,stat=%d", dataObjInp->objPath, status ); } else { *dataObjInfoHead = rei.doi; } return status; }
int getRescGrpForCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp, rescGrpInfo_t** myRescGrpInfo ) { int status; ruleExecInfo_t rei; /* query rcat for resource info and sort it */ initReiWithDataObjInp( &rei, rsComm, dataObjInp ); if ( dataObjInp->oprType == REPLICATE_OPR ) { // JMC - backport 4660 status = applyRule( "acSetRescSchemeForRepl", NULL, &rei, NO_SAVE_REI ); } else { status = applyRule( "acSetRescSchemeForCreate", NULL, &rei, NO_SAVE_REI ); } if ( status < 0 ) { if ( rei.status < 0 ) { status = rei.status; } rodsLog( LOG_NOTICE, "getRescGrpForCreate:acSetRescSchemeForCreate error for %s,status=%d", dataObjInp->objPath, status ); return ( status ); } if ( rei.rgi == NULL ) { /* def resc group has not been initialized yet */ // JMC - legacy resource status = setDefaultResc (rsComm, NULL, NULL, &dataObjInp->condInput, myRescGrpInfo ); //if( !(*myRescGrpInfo) ) { ( *myRescGrpInfo ) = new rescGrpInfo_t; bzero( ( *myRescGrpInfo ), sizeof( rescGrpInfo_t ) ); ( *myRescGrpInfo )->rescInfo = new rescInfo_t; //} irods::error set_err = irods::set_default_resource( rsComm, "", "", &dataObjInp->condInput, *( *myRescGrpInfo ) ); if ( !set_err.ok() ) { irods::log( PASS( set_err ) ); return SYS_INVALID_RESC_INPUT; } } else { *myRescGrpInfo = rei.rgi; } status = setRescQuota( rsComm, dataObjInp->objPath, myRescGrpInfo, dataObjInp->dataSize ); if ( status == SYS_RESC_QUOTA_EXCEEDED ) { return SYS_RESC_QUOTA_EXCEEDED; } return 0; // JMC - should this be 1 per above block? }
int getRescForCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp, std::string& _resc_name ) { int status; ruleExecInfo_t rei; /* query rcat for resource info and sort it */ initReiWithDataObjInp( &rei, rsComm, dataObjInp ); if ( dataObjInp->oprType == REPLICATE_OPR ) { // JMC - backport 4660 status = applyRule( "acSetRescSchemeForRepl", NULL, &rei, NO_SAVE_REI ); } else { status = applyRule( "acSetRescSchemeForCreate", NULL, &rei, NO_SAVE_REI ); } if ( status < 0 ) { if ( rei.status < 0 ) { status = rei.status; } rodsLog( LOG_NOTICE, "getRescForCreate:acSetRescSchemeForCreate error for %s,status=%d", dataObjInp->objPath, status ); return status; } // get resource name if ( !strlen( rei.rescName ) ) { irods::error set_err = irods::set_default_resource( rsComm, "", "", &dataObjInp->condInput, _resc_name ); if ( !set_err.ok() ) { irods::log( PASS( set_err ) ); return SYS_INVALID_RESC_INPUT; } } else { _resc_name = rei.rescName; } #if 0 // #1472 status = setRescQuota( rsComm, dataObjInp->objPath, myRescGrpInfo, dataObjInp->dataSize ); if ( status == SYS_RESC_QUOTA_EXCEEDED ) { if ( rei.rgi == NULL ) { delete( *myRescGrpInfo )->rescInfo; delete( *myRescGrpInfo ); *myRescGrpInfo = NULL; } return SYS_RESC_QUOTA_EXCEEDED; } #endif return 0; // JMC - should this be 1 per above block? }
int _rsRmCollRecur( rsComm_t *rsComm, collInp_t *rmCollInp, collOprStat_t **collOprStat ) { int status; ruleExecInfo_t rei; int trashPolicy; dataObjInfo_t *dataObjInfo = NULL; /* check for specColl and permission */ status = resolvePathInSpecColl( rsComm, rmCollInp->collName, WRITE_COLL_PERM, 0, &dataObjInfo ); if ( status < 0 && status != CAT_NO_ROWS_FOUND ) { return status; } if ( status == COLL_OBJ_T && dataObjInfo->specColl != NULL && dataObjInfo->specColl->collClass == LINKED_COLL ) { rstrcpy( rmCollInp->collName, dataObjInfo->objPath, MAX_NAME_LEN ); free( dataObjInfo->specColl ); dataObjInfo->specColl = NULL; } if ( status != COLL_OBJ_T || dataObjInfo->specColl == NULL ) { /* a normal coll */ if ( rmCollInp->oprType != UNREG_OPR && getValByKey( &rmCollInp->condInput, FORCE_FLAG_KW ) == NULL && getValByKey( &rmCollInp->condInput, RMTRASH_KW ) == NULL && getValByKey( &rmCollInp->condInput, ADMIN_RMTRASH_KW ) == NULL ) { initReiWithDataObjInp( &rei, rsComm, NULL ); status = applyRule( "acTrashPolicy", NULL, &rei, NO_SAVE_REI ); trashPolicy = rei.status; if ( trashPolicy != NO_TRASH_CAN ) { status = rsMvCollToTrash( rsComm, rmCollInp ); if ( status >= 0 && collOprStat != NULL ) { if ( *collOprStat == NULL ) { *collOprStat = ( collOprStat_t* )malloc( sizeof( collOprStat_t ) ); memset( *collOprStat, 0, sizeof( collOprStat_t ) ); } ( *collOprStat )->filesCnt = 1; ( *collOprStat )->totalFileCnt = 1; rstrcpy( ( *collOprStat )->lastObjPath, rmCollInp->collName, MAX_NAME_LEN ); } return status; } } } /* got here. will recursively phy delete the collection */ status = _rsPhyRmColl( rsComm, rmCollInp, dataObjInfo, collOprStat ); if ( dataObjInfo != NULL ) { freeDataObjInfo( dataObjInfo ); } return status; }
int chkRescQuotaPolicy( rsComm_t *rsComm ) { int status; ruleExecInfo_t rei; if ( RescQuotaPolicy == RESC_QUOTA_UNINIT ) { initReiWithDataObjInp( &rei, rsComm, NULL ); status = applyRule( "acRescQuotaPolicy", NULL, &rei, NO_SAVE_REI ); if ( status < 0 ) { rodsLog( LOG_ERROR, "queRescQuota: acRescQuotaPolicy error status = %d", status ); RescQuotaPolicy = RESC_QUOTA_OFF; } } return RescQuotaPolicy; }
int chkPreProcDeleteRule( rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp, dataObjInfo_t *dataObjInfoHead ) { dataObjInfo_t *tmpDataObjInfo; ruleExecInfo_t rei; int status = 0; initReiWithDataObjInp( &rei, rsComm, dataObjUnlinkInp ); tmpDataObjInfo = dataObjInfoHead; while ( tmpDataObjInfo != NULL ) { /* have to go through the loop to test each copy (resource). */ rei.doi = tmpDataObjInfo; // make resource properties available as rule session variables rei.condInputData = (keyValPair_t *)malloc(sizeof(keyValPair_t)); memset(rei.condInputData, 0, sizeof(keyValPair_t)); irods::get_resc_properties_as_kvp(rei.doi->rescHier, rei.condInputData); status = applyRule( "acDataDeletePolicy", NULL, &rei, NO_SAVE_REI ); if ( status < 0 && status != NO_MORE_RULES_ERR && status != SYS_DELETE_DISALLOWED ) { rodsLog( LOG_ERROR, "chkPreProcDeleteRule: acDataDeletePolicy err for %s. stat = %d", dataObjUnlinkInp->objPath, status ); return status; } if ( rei.status == SYS_DELETE_DISALLOWED ) { rodsLog( LOG_ERROR, "chkPreProcDeleteRule:acDataDeletePolicy disallowed delete of %s", dataObjUnlinkInp->objPath ); return rei.status; } tmpDataObjInfo = tmpDataObjInfo->next; } return status; }
int filePathReg (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp, char *filePath, rescInfo_t *rescInfo) { dataObjInfo_t dataObjInfo; int status; initDataObjInfoWithInp (&dataObjInfo, phyPathRegInp); dataObjInfo.replStatus = NEWLY_CREATED_COPY; dataObjInfo.rescInfo = rescInfo; rstrcpy (dataObjInfo.rescName, rescInfo->rescName, NAME_LEN); if (dataObjInfo.dataSize <= 0 && (dataObjInfo.dataSize = getSizeInVault (rsComm, &dataObjInfo)) < 0) { status = (int) dataObjInfo.dataSize; rodsLog (LOG_ERROR, "filePathReg: getSizeInVault for %s failed, status = %d", dataObjInfo.objPath, status); return (status); } status = svrRegDataObj (rsComm, &dataObjInfo); if (status < 0) { rodsLog (LOG_ERROR, "filePathReg: rsRegDataObj for %s failed, status = %d", dataObjInfo.objPath, status); } else { ruleExecInfo_t rei; initReiWithDataObjInp (&rei, rsComm, phyPathRegInp); rei.doi = &dataObjInfo; rei.status = status; rei.status = applyRule ("acPostProcForFilePathReg", NULL, &rei, NO_SAVE_REI); } return (status); }
int getNumThreads (rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr, keyValPair_t *condInput, char *destRescName, char *srcRescName) { ruleExecInfo_t rei; dataObjInp_t doinp; int status; int numDestThr = -1; int numSrcThr = -1; rescGrpInfo_t *rescGrpInfo; if (inpNumThr == NO_THREADING) return 0; if (dataSize < 0) return 0; if (dataSize <= MIN_SZ_FOR_PARA_TRAN) { if (inpNumThr > 0) { inpNumThr = 1; } else { return 0; } } if (getValByKey (condInput, NO_PARA_OP_KW) != NULL) { /* client specify no para opr */ return (1); } #ifndef PARA_OPR return (1); #endif memset (&doinp, 0, sizeof (doinp)); doinp.numThreads = inpNumThr; doinp.dataSize = dataSize; initReiWithDataObjInp (&rei, rsComm, &doinp); if (destRescName != NULL) { rescGrpInfo = NULL; status = resolveAndQueResc (destRescName, NULL, &rescGrpInfo); if (status >= 0) { rei.rgi = rescGrpInfo; status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI); freeRescGrpInfo (rescGrpInfo); if (status < 0) { rodsLog (LOG_ERROR, "getNumThreads: acGetNumThreads error, status = %d", status); } else { numDestThr = rei.status; if (numDestThr == 0) { return 0; } else if (numDestThr == 1 && srcRescName == NULL && isLocalHost (rescGrpInfo->rescInfo->rescLoc)) { /* one thread and resouce on local host */ return 0; } } } } if (srcRescName != NULL) { if (numDestThr > 0 && strcmp (destRescName, srcRescName) == 0) return numDestThr; rescGrpInfo = NULL; status = resolveAndQueResc (srcRescName, NULL, &rescGrpInfo); if (status >= 0) { rei.rgi = rescGrpInfo; status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI); freeRescGrpInfo (rescGrpInfo); if (status < 0) { rodsLog (LOG_ERROR, "getNumThreads: acGetNumThreads error, status = %d", status); } else { numSrcThr = rei.status; if (numSrcThr == 0) return 0; } } } /* At this point, number of threads for both source and destination have been set based on acSetNumThreads policy point, and neither of them are set to 0 (to turn off threading). If both numDestThr and numSrcThr are set, choose the smallest one. The reasoning is that acSetNumThreads is used by a site to limit the default maximum parallel threads, so we should honor the most restrictive setting. */ if (numDestThr > 0 && numSrcThr > 0) { if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) { return 1; } else if (numDestThr < numSrcThr) { return numDestThr; } else { return numSrcThr; } } if (numDestThr > 0) { if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) { return 1; } else { return numDestThr; } } if (numSrcThr > 0) { if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) { return 1; } else { return numSrcThr; } } /* should not be here. do one with no resource */ rei.rgi = NULL; status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI); if (status < 0) { rodsLog (LOG_ERROR, "getNumThreads: acGetNumThreads error, status = %d", status); return 0; } else { if (rei.status > 0) return rei.status; else return 0; } }
int getNumThreads( rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr, keyValPair_t *condInput, char *destRescHier, char *srcRescHier, int oprType ) { ruleExecInfo_t rei; dataObjInp_t doinp; int status; int numDestThr = -1; int numSrcThr = -1; if ( inpNumThr == NO_THREADING ) { return 0; } if ( dataSize < 0 ) { return 0; } if ( dataSize <= MIN_SZ_FOR_PARA_TRAN ) { if ( inpNumThr > 0 ) { inpNumThr = 1; } else { return 0; } } if ( getValByKey( condInput, NO_PARA_OP_KW ) != NULL ) { /* client specify no para opr */ return 1; } memset( &doinp, 0, sizeof( doinp ) ); doinp.numThreads = inpNumThr; doinp.dataSize = dataSize; doinp.oprType = oprType; initReiWithDataObjInp( &rei, rsComm, &doinp ); if (destRescHier && strlen(destRescHier)) { // get resource (hierarchy) location std::string location; irods::error ret = irods::get_loc_for_hier_string( destRescHier, location ); if ( !ret.ok() ) { irods::log( PASSMSG( "getNumThreads - failed in get_loc_for_hier_string", ret ) ); return -1; } irods::hierarchy_parser parser; parser.set_string( destRescHier ); std::string last_resc; parser.last_resc( last_resc ); irods::error err = irods::is_resc_live( last_resc.c_str() ); if ( err.ok() ) { status = applyRule( "acSetNumThreads", NULL, &rei, NO_SAVE_REI ); if ( status < 0 ) { rodsLog( LOG_ERROR, "getNumThreads: acGetNumThreads error, status = %d", status ); } else { numDestThr = rei.status; if ( numDestThr == 0 ) { return 0; } else if ( numDestThr == 1 && srcRescHier == NULL && isLocalHost( location.c_str() ) ) { /* one thread and resource on local host */ return 0; } } } } if (destRescHier && strlen(destRescHier) && srcRescHier && strlen(srcRescHier)) { if ( numDestThr > 0 && strcmp( destRescHier, srcRescHier ) == 0 ) { return numDestThr; } // get resource (hierarchy) location std::string location; irods::error ret = irods::get_loc_for_hier_string( destRescHier, location ); if ( !ret.ok() ) { irods::log( PASSMSG( "getNumThreads - failed in get_loc_for_hier_string", ret ) ); return -1; } irods::hierarchy_parser parser; parser.set_string( srcRescHier ); std::string last_resc; parser.last_resc( last_resc ); irods::error err = irods::is_resc_live( last_resc.c_str() ); if ( err.ok() ) { status = applyRule( "acSetNumThreads", NULL, &rei, NO_SAVE_REI ); if ( status < 0 ) { rodsLog( LOG_ERROR, "getNumThreads: acGetNumThreads error, status = %d", status ); } else { numSrcThr = rei.status; if ( numSrcThr == 0 ) { return 0; } } } } if ( numDestThr > 0 ) { if ( getValByKey( condInput, RBUDP_TRANSFER_KW ) != NULL ) { return 1; } else { return numDestThr; } } if ( numSrcThr > 0 ) { if ( getValByKey( condInput, RBUDP_TRANSFER_KW ) != NULL ) { return 1; } else { return numSrcThr; } } /* should not be here. do one with no resource */ status = applyRule( "acSetNumThreads", NULL, &rei, NO_SAVE_REI ); if ( status < 0 ) { rodsLog( LOG_ERROR, "getNumThreads: acGetNumThreads error, status = %d", status ); return 0; } else { if ( rei.status > 0 ) { return rei.status; } else { return 0; } } }
int filePathReg (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp, char *filePath, rescInfo_t *rescInfo) { dataObjInfo_t dataObjInfo; int status; char *rescGroupName = NULL; char *chksum; initDataObjInfoWithInp (&dataObjInfo, phyPathRegInp); if ((rescGroupName = getValByKey (&phyPathRegInp->condInput, RESC_GROUP_NAME_KW)) != NULL) { rstrcpy (dataObjInfo.rescGroupName, rescGroupName, NAME_LEN); } dataObjInfo.replStatus = NEWLY_CREATED_COPY; dataObjInfo.rescInfo = rescInfo; rstrcpy (dataObjInfo.rescName, rescInfo->rescName, NAME_LEN); if (dataObjInfo.dataSize <= 0 && #ifdef FILESYSTEM_META (dataObjInfo.dataSize = getFileMetadataFromVault (rsComm, &dataObjInfo)) < 0 && #else (dataObjInfo.dataSize = getSizeInVault (rsComm, &dataObjInfo)) < 0 && #endif dataObjInfo.dataSize != UNKNOWN_FILE_SZ) { status = (int) dataObjInfo.dataSize; rodsLog (LOG_ERROR, #ifdef FILESYSTEM_META "filePathReg: getFileMetadataFromVault for %s failed, status = %d", #else "filePathReg: getSizeInVault for %s failed, status = %d", #endif dataObjInfo.objPath, status); return (status); } #ifdef FILESYSTEM_META addKeyVal(&dataObjInfo.condInput, FILE_SOURCE_PATH_KW, filePath); #endif if ((chksum = getValByKey (&phyPathRegInp->condInput, REG_CHKSUM_KW)) != NULL) { rstrcpy (dataObjInfo.chksum, chksum, NAME_LEN); } else if ((chksum = getValByKey (&phyPathRegInp->condInput, VERIFY_CHKSUM_KW)) != NULL) { status = _dataObjChksum (rsComm, &dataObjInfo, &chksum); if (status < 0) { rodsLog (LOG_ERROR, "rodsPathReg: _dataObjChksum for %s failed, status = %d", dataObjInfo.objPath, status); return (status); } rstrcpy (dataObjInfo.chksum, chksum, NAME_LEN); } status = svrRegDataObj (rsComm, &dataObjInfo); if (status < 0) { rodsLog (LOG_ERROR, "filePathReg: rsRegDataObj for %s failed, status = %d", dataObjInfo.objPath, status); } else { ruleExecInfo_t rei; initReiWithDataObjInp (&rei, rsComm, phyPathRegInp); rei.doi = &dataObjInfo; rei.status = status; rei.status = applyRule ("acPostProcForFilePathReg", NULL, &rei, NO_SAVE_REI); } return (status); }
int getNumThreads (rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr, keyValPair_t *condInput, char *destRescName, char *srcRescName) { ruleExecInfo_t rei; dataObjInp_t doinp; int status; int numDestThr = -1; int numSrcThr = -1; rescGrpInfo_t *rescGrpInfo; if (inpNumThr == NO_THREADING) return 0; if (dataSize < 0) return 0; if (dataSize <= MIN_SZ_FOR_PARA_TRAN) { if (inpNumThr > 0) { inpNumThr = 1; } else { return 0; } } if (getValByKey (condInput, NO_PARA_OP_KW) != NULL) { /* client specify no para opr */ return (1); } #ifndef PARA_OPR return (1); #endif memset (&doinp, 0, sizeof (doinp)); doinp.numThreads = inpNumThr; doinp.dataSize = dataSize; initReiWithDataObjInp (&rei, rsComm, &doinp); if (destRescName != NULL) { rescGrpInfo = NULL; status = resolveAndQueResc (destRescName, NULL, &rescGrpInfo); if (status >= 0) { rei.rgi = rescGrpInfo; status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI); freeRescGrpInfo (rescGrpInfo); if (status < 0) { rodsLog (LOG_ERROR, "getNumThreads: acGetNumThreads error, status = %d", status); } else { numDestThr = rei.status; if (numDestThr == 0) { return 0; } else if (numDestThr == 1 && srcRescName == NULL && isLocalHost (rescGrpInfo->rescInfo->rescLoc)) { /* one thread and resouce on local host */ return 0; } } } } if (srcRescName != NULL) { if (numDestThr > 0 && strcmp (destRescName, srcRescName) == 0) return numDestThr; rescGrpInfo = NULL; status = resolveAndQueResc (srcRescName, NULL, &rescGrpInfo); if (status >= 0) { rei.rgi = rescGrpInfo; status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI); freeRescGrpInfo (rescGrpInfo); if (status < 0) { rodsLog (LOG_ERROR, "getNumThreads: acGetNumThreads error, status = %d", status); } else { numSrcThr = rei.status; if (numSrcThr == 0) return 0; } } } if (numDestThr > 0) { if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) { return 1; } else { return numDestThr; } } if (numSrcThr > 0) { if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) { return 1; } else { return numSrcThr; } } /* should not be here. do one with no resource */ rei.rgi = NULL; status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI); if (status < 0) { rodsLog (LOG_ERROR, "getNumThreads: acGetNumThreads error, status = %d", status); return 0; } else { if (rei.status > 0) return rei.status; else return 0; } }
int dataObjUnlinkS (rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp, dataObjInfo_t *dataObjInfo) { int status; unregDataObj_t unregDataObjInp; if (dataObjInfo->specColl == NULL) { if (dataObjUnlinkInp->oprType == UNREG_OPR && rsComm->clientUser.authInfo.authFlag != LOCAL_PRIV_USER_AUTH) { ruleExecInfo_t rei; initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp); rei.doi = dataObjInfo; rei.status = DO_CHK_PATH_PERM; /* default */ applyRule ("acSetChkFilePathPerm", NULL, &rei, NO_SAVE_REI); if (rei.status != NO_CHK_PATH_PERM) { char *outVaultPath; rodsServerHost_t *rodsServerHost; status = resolveHostByRescInfo (dataObjInfo->rescInfo, &rodsServerHost); if (status < 0) return status; /* unregistering but not an admin user */ status = matchVaultPath (rsComm, dataObjInfo->filePath, rodsServerHost, &outVaultPath); if (status != 0) { /* in the vault */ rodsLog (LOG_DEBUG, "dataObjUnlinkS: unregistering in vault file %s", dataObjInfo->filePath); return CANT_UNREG_IN_VAULT_FILE; } } #if 0 /* don't need this since we are doing orphan */ } else if (RescTypeDef[dataObjInfo->rescInfo->rescTypeInx].driverType == WOS_FILE_TYPE && dataObjUnlinkInp->oprType != UNREG_OPR) { /* WOS_FILE_TYPE, unlink first before unreg because orphan files * cannot be reclaimed */ status = l3Unlink (rsComm, dataObjInfo); if (status < 0) { rodsLog (LOG_NOTICE, "dataObjUnlinkS: l3Unlink error for WOS file %s. status = %d", dataObjUnlinkInp->objPath, status); return status; } unregDataObjInp.dataObjInfo = dataObjInfo; unregDataObjInp.condInput = &dataObjUnlinkInp->condInput; status = rsUnregDataObj (rsComm, &unregDataObjInp); if (status < 0) { rodsLog (LOG_NOTICE, "dataObjUnlinkS: rsUnregDataObj error for %s. status = %d", dataObjUnlinkInp->objPath, status); } return status; #endif } unregDataObjInp.dataObjInfo = dataObjInfo; unregDataObjInp.condInput = &dataObjUnlinkInp->condInput; status = rsUnregDataObj (rsComm, &unregDataObjInp); if (status < 0) { rodsLog (LOG_NOTICE, "dataObjUnlinkS: rsUnregDataObj error for %s. status = %d", dataObjUnlinkInp->objPath, status); return status; } } if (dataObjUnlinkInp->oprType != UNREG_OPR) { status = l3Unlink (rsComm, dataObjInfo); if (status < 0) { int myError = getErrno (status); rodsLog (LOG_NOTICE, "dataObjUnlinkS: l3Unlink error for %s. status = %d", dataObjUnlinkInp->objPath, status); /* allow ENOENT to go on and unregister */ if (myError != ENOENT && myError != EACCES) { char orphanPath[MAX_NAME_LEN]; int status1 = 0; rodsLog (LOG_NOTICE, "dataObjUnlinkS: orphan file %s", dataObjInfo->filePath); while (1) { if (isOrphanPath (dataObjUnlinkInp->objPath) == NOT_ORPHAN_PATH) { /* don't rename orphan path */ status1 = rsMkOrphanPath (rsComm, dataObjInfo->objPath, orphanPath); if (status1 < 0) break; /* reg the orphan path */ rstrcpy (dataObjInfo->objPath, orphanPath,MAX_NAME_LEN); } status1 = svrRegDataObj (rsComm, dataObjInfo); if (status1 == CAT_NAME_EXISTS_AS_DATAOBJ || status1 == CATALOG_ALREADY_HAS_ITEM_BY_THAT_NAME) { continue; } else if (status1 < 0) { rodsLogError (LOG_ERROR, status1, "dataObjUnlinkS: svrRegDataObj of orphan %s error", dataObjInfo->objPath); } break; } return (status); } else { status = 0; } } } return (status); }
int rsMvCollToTrash( rsComm_t *rsComm, collInp_t *rmCollInp ) { int status; char trashPath[MAX_NAME_LEN]; dataObjCopyInp_t dataObjRenameInp; genQueryInp_t genQueryInp; genQueryOut_t *genQueryOut = NULL; int continueInx; dataObjInfo_t dataObjInfo; /* check permission of files */ memset( &genQueryInp, 0, sizeof( genQueryInp ) ); status = rsQueryDataObjInCollReCur( rsComm, rmCollInp->collName, &genQueryInp, &genQueryOut, ACCESS_DELETE_OBJECT, 0 ); memset( &dataObjInfo, 0, sizeof( dataObjInfo ) ); while ( status >= 0 ) { sqlResult_t *subColl, *dataObj, *rescName; ruleExecInfo_t rei; /* check if allow to delete */ if ( ( subColl = getSqlResultByInx( genQueryOut, COL_COLL_NAME ) ) == NULL ) { rodsLog( LOG_ERROR, "rsMvCollToTrash: getSqlResultByInx for COL_COLL_NAME failed" ); return UNMATCHED_KEY_OR_INDEX; } if ( ( dataObj = getSqlResultByInx( genQueryOut, COL_DATA_NAME ) ) == NULL ) { rodsLog( LOG_ERROR, "rsMvCollToTrash: getSqlResultByInx for COL_DATA_NAME failed" ); return UNMATCHED_KEY_OR_INDEX; } if ( ( rescName = getSqlResultByInx( genQueryOut, COL_D_RESC_NAME ) ) == NULL ) { rodsLog( LOG_ERROR, "rsMvCollToTrash: getSqlResultByInx for COL_D_RESC_NAME failed" ); return UNMATCHED_KEY_OR_INDEX; } snprintf( dataObjInfo.objPath, MAX_NAME_LEN, "%s/%s", subColl->value, dataObj->value ); rstrcpy( dataObjInfo.rescName, rescName->value, NAME_LEN ); initReiWithDataObjInp( &rei, rsComm, NULL ); rei.doi = &dataObjInfo; status = applyRule( "acDataDeletePolicy", NULL, &rei, NO_SAVE_REI ); if ( status < 0 && status != NO_MORE_RULES_ERR && status != SYS_DELETE_DISALLOWED ) { rodsLog( LOG_NOTICE, "rsMvCollToTrash: acDataDeletePolicy error for %s. status = %d", dataObjInfo.objPath, status ); return status; } if ( rei.status == SYS_DELETE_DISALLOWED ) { rodsLog( LOG_NOTICE, "rsMvCollToTrash:disallowed for %s via DataDeletePolicy,status=%d", dataObjInfo.objPath, rei.status ); return rei.status; } continueInx = genQueryOut->continueInx; freeGenQueryOut( &genQueryOut ); if ( continueInx > 0 ) { /* More to come */ genQueryInp.continueInx = continueInx; status = rsGenQuery( rsComm, &genQueryInp, &genQueryOut ); } else { break; } } if ( status < 0 && status != CAT_NO_ROWS_FOUND ) { rodsLog( LOG_ERROR, "rsMvCollToTrash: rsQueryDataObjInCollReCur error for %s, stat=%d", rmCollInp->collName, status ); return status; } status = rsMkTrashPath( rsComm, rmCollInp->collName, trashPath ); if ( status < 0 ) { appendRandomToPath( trashPath ); status = rsMkTrashPath( rsComm, rmCollInp->collName, trashPath ); if ( status < 0 ) { return status; } } memset( &dataObjRenameInp, 0, sizeof( dataObjRenameInp ) ); dataObjRenameInp.srcDataObjInp.oprType = dataObjRenameInp.destDataObjInp.oprType = RENAME_COLL; rstrcpy( dataObjRenameInp.destDataObjInp.objPath, trashPath, MAX_NAME_LEN ); rstrcpy( dataObjRenameInp.srcDataObjInp.objPath, rmCollInp->collName, MAX_NAME_LEN ); status = rsDataObjRename( rsComm, &dataObjRenameInp ); while ( status == CAT_NAME_EXISTS_AS_COLLECTION ) { appendRandomToPath( dataObjRenameInp.destDataObjInp.objPath ); status = rsDataObjRename( rsComm, &dataObjRenameInp ); } if ( status < 0 ) { rodsLog( LOG_ERROR, "mvCollToTrash: rcDataObjRename error for %s, status = %d", dataObjRenameInp.destDataObjInp.objPath, status ); return status; } return status; }
int dataObjUnlinkS( rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp, dataObjInfo_t *dataObjInfo ) { int status = 0; unregDataObj_t unregDataObjInp; if ( dataObjInfo->specColl == NULL ) { if ( dataObjUnlinkInp->oprType == UNREG_OPR && rsComm->clientUser.authInfo.authFlag != LOCAL_PRIV_USER_AUTH ) { ruleExecInfo_t rei; initReiWithDataObjInp( &rei, rsComm, dataObjUnlinkInp ); rei.doi = dataObjInfo; rei.status = DO_CHK_PATH_PERM; /* default */ // JMC - backport 4758 // make resource properties available as rule session variables rei.condInputData = (keyValPair_t *)malloc(sizeof(keyValPair_t)); memset(rei.condInputData, 0, sizeof(keyValPair_t)); irods::get_resc_properties_as_kvp(rei.doi->rescHier, rei.condInputData); applyRule( "acSetChkFilePathPerm", NULL, &rei, NO_SAVE_REI ); if ( rei.status != NO_CHK_PATH_PERM ) { // =-=-=-=-=-=-=- // extract the host location from the resource hierarchy std::string location; irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location ); if ( !ret.ok() ) { irods::log( PASSMSG( "dataObjUnlinkS - failed in get_loc_for_hier_string", ret ) ); return ret.code(); } rodsHostAddr_t addr; rodsServerHost_t *rodsServerHost = 0; memset( &addr, 0, sizeof( addr ) ); rstrcpy( addr.hostAddr, location.c_str(), NAME_LEN ); int remoteFlag = resolveHost( &addr, &rodsServerHost ); if ( remoteFlag < 0 ) { // error condition? } /* unregistering but not an admin user */ std::string out_path; ret = resc_mgr.validate_vault_path( dataObjInfo->filePath, rodsServerHost, out_path ); if ( !ret.ok() ) { /* in the vault */ std::stringstream msg; msg << "unregistering a data object which is in a vault ["; msg << dataObjInfo->filePath << "]"; irods::log( PASSMSG( msg.str(), ret ) ); return CANT_UNREG_IN_VAULT_FILE; } } } unregDataObjInp.dataObjInfo = dataObjInfo; unregDataObjInp.condInput = &dataObjUnlinkInp->condInput; status = rsUnregDataObj( rsComm, &unregDataObjInp ); if ( status < 0 ) { rodsLog( LOG_NOTICE, "dataObjUnlinkS: rsUnregDataObj error for %s. status = %d", dataObjUnlinkInp->objPath, status ); return status; } } if ( dataObjUnlinkInp->oprType != UNREG_OPR ) { // Set the in_pdmo flag char* in_pdmo = getValByKey( &dataObjUnlinkInp->condInput, IN_PDMO_KW ); if ( in_pdmo != NULL ) { rstrcpy( dataObjInfo->in_pdmo, in_pdmo, MAX_NAME_LEN ); } else { dataObjInfo->in_pdmo[0] = '\0'; } status = l3Unlink( rsComm, dataObjInfo ); if ( status < 0 ) { int myError = getErrno( status ); rodsLog( LOG_NOTICE, "dataObjUnlinkS: l3Unlink error for %s. status = %d", dataObjUnlinkInp->objPath, status ); /* allow ENOENT to go on and unregister */ if ( myError != ENOENT && myError != EACCES ) { char orphanPath[MAX_NAME_LEN]; int status1 = 0; rodsLog( LOG_NOTICE, "dataObjUnlinkS: orphan file %s", dataObjInfo->filePath ); while ( 1 ) { if ( isOrphanPath( dataObjUnlinkInp->objPath ) == NOT_ORPHAN_PATH ) { /* don't rename orphan path */ status1 = rsMkOrphanPath( rsComm, dataObjInfo->objPath, orphanPath ); if ( status1 < 0 ) { break; } /* reg the orphan path */ rstrcpy( dataObjInfo->objPath, orphanPath, MAX_NAME_LEN ); } status1 = svrRegDataObj( rsComm, dataObjInfo ); if ( status1 == CAT_NAME_EXISTS_AS_DATAOBJ || status1 == CATALOG_ALREADY_HAS_ITEM_BY_THAT_NAME ) { continue; } else if ( status1 < 0 ) { rodsLogError( LOG_ERROR, status1, "dataObjUnlinkS: svrRegDataObj of orphan %s error", dataObjInfo->objPath ); } break; } return status; } else { status = 0; } } } 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 chkCollForExtAndReg (rsComm_t *rsComm, char *collection, rodsObjStat_t **rodsObjStatOut) { dataObjInp_t dataObjInp; int status; rodsObjStat_t *myRodsObjStat = NULL; bzero (&dataObjInp, sizeof (dataObjInp)); rstrcpy (dataObjInp.objPath, collection, MAX_NAME_LEN); #if 0 /* allow mounted coll */ status = collStat (rsComm, &dataObjInp, &myRodsObjStat); #endif status = collStatAllKinds (rsComm, &dataObjInp, &myRodsObjStat); #if 0 if (status == CAT_NO_ROWS_FOUND || status == OBJ_PATH_DOES_NOT_EXIST || status == USER_FILE_DOES_NOT_EXIST) { #endif if (status < 0) { status = rsMkCollR (rsComm, "/", collection); if (status < 0) { rodsLog (LOG_ERROR, "chkCollForExtAndReg: rsMkCollR of %s error. status = %d", collection, status); return (status); } else { #if 0 /* allow mounted coll */ status = collStat (rsComm, &dataObjInp, &myRodsObjStat); #endif status = collStatAllKinds (rsComm, &dataObjInp, &myRodsObjStat); } } if (status < 0) { rodsLog (LOG_ERROR, "chkCollForExtAndReg: collStat of %s error. status = %d", dataObjInp.objPath, status); return (status); } else if (myRodsObjStat->specColl != NULL && myRodsObjStat->specColl->collClass != MOUNTED_COLL) { /* only do mounted coll */ freeRodsObjStat (myRodsObjStat); rodsLog (LOG_ERROR, "chkCollForExtAndReg: %s is a struct file collection", dataObjInp.objPath); return (SYS_STRUCT_FILE_INMOUNTED_COLL); } if (myRodsObjStat->specColl == NULL) { status = checkCollAccessPerm (rsComm, collection, ACCESS_DELETE_OBJECT); } else { status = checkCollAccessPerm (rsComm, myRodsObjStat->specColl->collection, ACCESS_DELETE_OBJECT); } if (status < 0) { rodsLog (LOG_ERROR, "chkCollForExtAndReg: no permission to write %s, status = %d", collection, status); freeRodsObjStat (myRodsObjStat); } else { if (rodsObjStatOut != NULL) { *rodsObjStatOut = myRodsObjStat; } else { freeRodsObjStat (myRodsObjStat); } } return (status); } /* regUnbunSubfiles - non bulk version of registering all files in phyBunDir * to the collection. Valid values for flags are: * FORCE_FLAG_FLAG. */ int regUnbunSubfiles (rsComm_t *rsComm, rescInfo_t *rescInfo, char *rescGroupName, char *collection, char *phyBunDir, int flags, genQueryOut_t *attriArray) { #ifndef USE_BOOST_FS DIR *dirPtr; struct dirent *myDirent; struct stat statbuf; #endif char subfilePath[MAX_NAME_LEN]; char subObjPath[MAX_NAME_LEN]; dataObjInp_t dataObjInp; int status; int savedStatus = 0; rodsLong_t st_size; #ifdef USE_BOOST_FS path srcDirPath (phyBunDir); if (!exists(srcDirPath) || !is_directory(srcDirPath)) { #else dirPtr = opendir (phyBunDir); if (dirPtr == NULL) { #endif rodsLog (LOG_ERROR, "regUnbunphySubfiles: opendir error for %s, errno = %d", phyBunDir, errno); return (UNIX_FILE_OPENDIR_ERR - errno); } bzero (&dataObjInp, sizeof (dataObjInp)); #ifdef USE_BOOST_FS directory_iterator end_itr; // default construction yields past-the-end for (directory_iterator itr(srcDirPath); itr != end_itr;++itr) { path p = itr->path(); snprintf (subfilePath, MAX_NAME_LEN, "%s", p.c_str ()); #else while ((myDirent = readdir (dirPtr)) != NULL) { if (strcmp (myDirent->d_name, ".") == 0 || strcmp (myDirent->d_name, "..") == 0) { continue; } snprintf (subfilePath, MAX_NAME_LEN, "%s/%s", phyBunDir, myDirent->d_name); #endif #ifdef USE_BOOST_FS if (!exists (p)) { #else status = lstat (subfilePath, &statbuf); if (status != 0) { #endif rodsLog (LOG_ERROR, "regUnbunphySubfiles: stat error for %s, errno = %d", subfilePath, errno); savedStatus = UNIX_FILE_STAT_ERR - errno; unlink (subfilePath); continue; } #ifdef USE_BOOST_FS if (is_symlink (p)) { #else if ((statbuf.st_mode & S_IFLNK) == S_IFLNK) { #endif rodsLogError (LOG_ERROR, SYMLINKED_BUNFILE_NOT_ALLOWED, "regUnbunSubfiles: %s is a symlink", subfilePath); savedStatus = SYMLINKED_BUNFILE_NOT_ALLOWED; continue; } #ifdef USE_BOOST_FS path childPath = p.filename(); snprintf (subObjPath, MAX_NAME_LEN, "%s/%s", collection, childPath.c_str()); if (is_directory (p)) { #else snprintf (subObjPath, MAX_NAME_LEN, "%s/%s", collection, myDirent->d_name); if ((statbuf.st_mode & S_IFDIR) != 0) { #endif status = rsMkCollR (rsComm, "/", subObjPath); if (status < 0) { rodsLog (LOG_ERROR, "regUnbunSubfiles: rsMkCollR of %s error. status = %d", subObjPath, status); savedStatus = status; continue; } status = regUnbunSubfiles (rsComm, rescInfo, rescGroupName, subObjPath, subfilePath, flags, attriArray); if (status < 0) { rodsLog (LOG_ERROR, "regUnbunSubfiles: regUnbunSubfiles of %s error. status=%d", subObjPath, status); savedStatus = status; continue; } #ifdef USE_BOOST_FS } else if (is_regular_file (p)) { st_size = file_size (p); #else } else if ((statbuf.st_mode & S_IFREG) != 0) { st_size = statbuf.st_size; #endif status = regSubfile (rsComm, rescInfo, rescGroupName, subObjPath, subfilePath, st_size, flags); unlink (subfilePath); if (status < 0) { rodsLog (LOG_ERROR, "regUnbunSubfiles: regSubfile of %s error. status=%d", subObjPath, status); savedStatus = status; continue; } } } #ifndef USE_BOOST_FS closedir (dirPtr); #endif rmdir (phyBunDir); return savedStatus; } int regSubfile (rsComm_t *rsComm, rescInfo_t *rescInfo, char *rescGroupName, char *subObjPath, char *subfilePath, rodsLong_t dataSize, int flags) { dataObjInfo_t dataObjInfo; dataObjInp_t dataObjInp; #ifndef USE_BOOST_FS struct stat statbuf; #endif int status; int modFlag = 0; bzero (&dataObjInp, sizeof (dataObjInp)); bzero (&dataObjInfo, sizeof (dataObjInfo)); rstrcpy (dataObjInp.objPath, subObjPath, MAX_NAME_LEN); rstrcpy (dataObjInfo.objPath, subObjPath, MAX_NAME_LEN); rstrcpy (dataObjInfo.rescName, rescInfo->rescName, NAME_LEN); rstrcpy (dataObjInfo.dataType, "generic", NAME_LEN); dataObjInfo.rescInfo = rescInfo; rstrcpy (dataObjInfo.rescGroupName, rescGroupName, NAME_LEN); dataObjInfo.dataSize = dataSize; status = getFilePathName (rsComm, &dataObjInfo, &dataObjInp); if (status < 0) { rodsLog (LOG_ERROR, "regSubFile: getFilePathName err for %s. status = %d", dataObjInp.objPath, status); return (status); } #ifdef USE_BOOST_FS path p (dataObjInfo.filePath); if (exists (p)) { if (is_directory (p)) { #else status = stat (dataObjInfo.filePath, &statbuf); if (status == 0 || errno != ENOENT) { if ((statbuf.st_mode & S_IFDIR) != 0) { #endif return SYS_PATH_IS_NOT_A_FILE; } if (chkOrphanFile (rsComm, dataObjInfo.filePath, rescInfo->rescName, &dataObjInfo) > 0) { /* an orphan file. just rename it */ fileRenameInp_t fileRenameInp; bzero (&fileRenameInp, sizeof (fileRenameInp)); rstrcpy (fileRenameInp.oldFileName, dataObjInfo.filePath, MAX_NAME_LEN); status = renameFilePathToNewDir (rsComm, ORPHAN_DIR, &fileRenameInp, rescInfo, 1); if (status < 0) { rodsLog (LOG_ERROR, "regSubFile: renameFilePathToNewDir err for %s. status = %d", fileRenameInp.oldFileName, status); return (status); } } else { /* not an orphan file */ if ((flags & FORCE_FLAG_FLAG) != 0 && dataObjInfo.dataId > 0 && strcmp (dataObjInfo.objPath, subObjPath) == 0) { /* overwrite the current file */ modFlag = 1; unlink (dataObjInfo.filePath); } else { status = SYS_COPY_ALREADY_IN_RESC; rodsLog (LOG_ERROR, "regSubFile: phypath %s is already in use. status = %d", dataObjInfo.filePath, status); return (status); } } } /* make the necessary dir */ mkDirForFilePath (UNIX_FILE_TYPE, rsComm, "/", dataObjInfo.filePath, getDefDirMode ()); /* add a link */ #ifndef windows_platform /* Windows does not support link */ status = link (subfilePath, dataObjInfo.filePath); if (status < 0) { rodsLog (LOG_ERROR, "regSubFile: link error %s to %s. errno = %d", subfilePath, dataObjInfo.filePath, errno); return (UNIX_FILE_LINK_ERR - errno); } #endif if (modFlag == 0) { status = svrRegDataObj (rsComm, &dataObjInfo); } else { char tmpStr[MAX_NAME_LEN]; modDataObjMeta_t modDataObjMetaInp; keyValPair_t regParam; bzero (&modDataObjMetaInp, sizeof (modDataObjMetaInp)); bzero (®Param, sizeof (regParam)); snprintf (tmpStr, MAX_NAME_LEN, "%lld", dataSize); addKeyVal (®Param, DATA_SIZE_KW, tmpStr); addKeyVal (®Param, ALL_REPL_STATUS_KW, tmpStr); snprintf (tmpStr, MAX_NAME_LEN, "%d", (int) time (NULL)); addKeyVal (®Param, DATA_MODIFY_KW, tmpStr); modDataObjMetaInp.dataObjInfo = &dataObjInfo; modDataObjMetaInp.regParam = ®Param; status = rsModDataObjMeta (rsComm, &modDataObjMetaInp); clearKeyVal (®Param); } if (status < 0) { rodsLog (LOG_ERROR, "regSubFile: svrRegDataObj of %s. errno = %d", dataObjInfo.objPath, errno); unlink (dataObjInfo.filePath); } else { ruleExecInfo_t rei; dataObjInp_t dataObjInp; bzero (&dataObjInp, sizeof (dataObjInp)); rstrcpy (dataObjInp.objPath, dataObjInfo.objPath, MAX_NAME_LEN); initReiWithDataObjInp (&rei, rsComm, &dataObjInp); rei.doi = &dataObjInfo; rei.status = applyRule ("acPostProcForTarFileReg", NULL, &rei, NO_SAVE_REI); if (rei.status < 0) { rodsLogError (LOG_ERROR, rei.status, "regSubFile: acPostProcForTarFileReg error for %s. status = %d", dataObjInfo.objPath); } } 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); }
int rsDataObjUnlink (rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp) { int status; ruleExecInfo_t rei; int trashPolicy; dataObjInfo_t *dataObjInfoHead = NULL; rodsServerHost_t *rodsServerHost = NULL; int rmTrashFlag = 0; specCollCache_t *specCollCache = NULL; resolveLinkedPath (rsComm, dataObjUnlinkInp->objPath, &specCollCache, &dataObjUnlinkInp->condInput); status = getAndConnRcatHost (rsComm, MASTER_RCAT, dataObjUnlinkInp->objPath, &rodsServerHost); if (status < 0) { return (status); } else if (rodsServerHost->rcatEnabled == REMOTE_ICAT) { int retval; retval = rcDataObjUnlink (rodsServerHost->conn, dataObjUnlinkInp); return status; } if (getValByKey ( &dataObjUnlinkInp->condInput, IRODS_ADMIN_RMTRASH_KW) != NULL || getValByKey ( &dataObjUnlinkInp->condInput, IRODS_RMTRASH_KW) != NULL) { if (isTrashPath (dataObjUnlinkInp->objPath) == False) { return (SYS_INVALID_FILE_PATH); } rmTrashFlag = 1; } dataObjUnlinkInp->openFlags = O_WRONLY; /* set the permission checking */ status = getDataObjInfoIncSpecColl (rsComm, dataObjUnlinkInp, &dataObjInfoHead); if (status < 0) return (status); if (rmTrashFlag == 1) { char *tmpAge; int ageLimit; if ((tmpAge = getValByKey (&dataObjUnlinkInp->condInput, AGE_KW)) != NULL) { ageLimit = atoi (tmpAge) * 60; if ((time (0) - atoi (dataObjInfoHead->dataModify)) < ageLimit) { /* younger than ageLimit. Nothing to do */ freeAllDataObjInfo (dataObjInfoHead); return 0; } } } if (dataObjUnlinkInp->oprType == UNREG_OPR || getValByKey (&dataObjUnlinkInp->condInput, FORCE_FLAG_KW) != NULL || getValByKey (&dataObjUnlinkInp->condInput, REPL_NUM_KW) != NULL || dataObjInfoHead->specColl != NULL || rmTrashFlag == 1) { status = _rsDataObjUnlink (rsComm, dataObjUnlinkInp, &dataObjInfoHead); } else { initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp); status = applyRule ("acTrashPolicy", NULL, &rei, NO_SAVE_REI); trashPolicy = rei.status; if (trashPolicy != NO_TRASH_CAN) { status = rsMvDataObjToTrash (rsComm, dataObjUnlinkInp, &dataObjInfoHead); freeAllDataObjInfo (dataObjInfoHead); return status; } else { status = _rsDataObjUnlink (rsComm, dataObjUnlinkInp, &dataObjInfoHead); } } initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp); rei.doi = dataObjInfoHead; rei.status = status; rei.status = applyRule ("acPostProcForDelete", NULL, &rei, NO_SAVE_REI); if (rei.status < 0) { rodsLog (LOG_NOTICE, "rsDataObjUnlink: acPostProcForDelete error for %s. status = %d", dataObjUnlinkInp->objPath, rei.status); } /* dataObjInfoHead may be outdated */ freeAllDataObjInfo (dataObjInfoHead); return (status); }
int rsDataObjUnlink( rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp ) { int status; ruleExecInfo_t rei; int trashPolicy; dataObjInfo_t *dataObjInfoHead = NULL; rodsServerHost_t *rodsServerHost = NULL; int rmTrashFlag = 0; specCollCache_t *specCollCache = NULL; resolveLinkedPath( rsComm, dataObjUnlinkInp->objPath, &specCollCache, &dataObjUnlinkInp->condInput ); status = getAndConnRcatHost( rsComm, MASTER_RCAT, ( const char* )dataObjUnlinkInp->objPath, &rodsServerHost ); if ( status < 0 || NULL == rodsServerHost ) { // JMC cppcheck - nullptr return status; } else if ( rodsServerHost->rcatEnabled == REMOTE_ICAT ) { rcDataObjUnlink( rodsServerHost->conn, dataObjUnlinkInp ); return status; } // =-=-=-=-=-=-=- // working on the "home zone", determine if we need to redirect to a different // server in this zone for this operation. if there is a RESC_HIER_STR_KW then // we know that the redirection decision has already been made // =-=-=-=-=-=-=- // determine the resource hierarchy if one is not provided addKeyVal( &dataObjUnlinkInp->condInput, irods::UNLINK_OPERATION.c_str(), "true" ); if ( getValByKey( &dataObjUnlinkInp->condInput, RESC_HIER_STR_KW ) == NULL ) { std::string hier; irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION, rsComm, dataObjUnlinkInp, hier ); if ( !ret.ok() ) { std::stringstream msg; msg << "failed in irods::resolve_resource_hierarchy for ["; msg << dataObjUnlinkInp->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( &dataObjUnlinkInp->condInput, RESC_HIER_STR_KW, hier.c_str() ); } // if keyword if ( getValByKey( &dataObjUnlinkInp->condInput, ADMIN_RMTRASH_KW ) != NULL || getValByKey( &dataObjUnlinkInp->condInput, RMTRASH_KW ) != NULL ) { if ( isTrashPath( dataObjUnlinkInp->objPath ) == False ) { return SYS_INVALID_FILE_PATH; } rmTrashFlag = 1; } dataObjUnlinkInp->openFlags = O_WRONLY; /* set the permission checking */ status = getDataObjInfoIncSpecColl( rsComm, dataObjUnlinkInp, &dataObjInfoHead ); if ( status < 0 ) { char* sys_error = NULL; const char* rods_error = rodsErrorName( status, &sys_error ); std::stringstream msg; msg << __FUNCTION__; msg << " - Failed to get data objects."; msg << " - " << rods_error << " " << sys_error; irods::error result = ERROR( status, msg.str() ); irods::log( result ); free( sys_error ); return status; } if ( rmTrashFlag == 1 ) { char *tmpAge; int ageLimit; if ( ( tmpAge = getValByKey( &dataObjUnlinkInp->condInput, AGE_KW ) ) != NULL ) { ageLimit = atoi( tmpAge ) * 60; if ( ( time( 0 ) - atoi( dataObjInfoHead->dataModify ) ) < ageLimit ) { /* younger than ageLimit. Nothing to do */ freeAllDataObjInfo( dataObjInfoHead ); return 0; } } } if ( dataObjUnlinkInp->oprType == UNREG_OPR || getValByKey( &dataObjUnlinkInp->condInput, FORCE_FLAG_KW ) != NULL || getValByKey( &dataObjUnlinkInp->condInput, REPL_NUM_KW ) != NULL || getValByKey( &dataObjUnlinkInp->condInput, EMPTY_BUNDLE_ONLY_KW ) != NULL || dataObjInfoHead->specColl != NULL || rmTrashFlag == 1 ) { status = _rsDataObjUnlink( rsComm, dataObjUnlinkInp, &dataObjInfoHead ); } else { initReiWithDataObjInp( &rei, rsComm, dataObjUnlinkInp ); status = applyRule( "acTrashPolicy", NULL, &rei, NO_SAVE_REI ); trashPolicy = rei.status; if ( trashPolicy != NO_TRASH_CAN ) { status = rsMvDataObjToTrash( rsComm, dataObjUnlinkInp, &dataObjInfoHead ); freeAllDataObjInfo( dataObjInfoHead ); return status; } else { status = _rsDataObjUnlink( rsComm, dataObjUnlinkInp, &dataObjInfoHead ); } } initReiWithDataObjInp( &rei, rsComm, dataObjUnlinkInp ); rei.doi = dataObjInfoHead; rei.status = status; // make resource properties available as rule session variables rei.condInputData = (keyValPair_t *)malloc(sizeof(keyValPair_t)); memset(rei.condInputData, 0, sizeof(keyValPair_t)); irods::get_resc_properties_as_kvp(rei.doi->rescHier, rei.condInputData); rei.status = applyRule( "acPostProcForDelete", NULL, &rei, NO_SAVE_REI ); if ( rei.status < 0 ) { rodsLog( LOG_NOTICE, "rsDataObjUnlink: acPostProcForDelete error for %s. status = %d", dataObjUnlinkInp->objPath, rei.status ); } /* dataObjInfoHead may be outdated */ freeAllDataObjInfo( dataObjInfoHead ); return status; }
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 _rsDataObjUnlink (rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp, dataObjInfo_t **dataObjInfoHead) { int status; int retVal = 0; dataObjInfo_t *tmpDataObjInfo, *myDataObjInfoHead; status = chkPreProcDeleteRule (rsComm, dataObjUnlinkInp, *dataObjInfoHead); if (status < 0) return status; #if 0 /* done in chkPreProcDeleteRule */ ruleExecInfo_t rei; initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp); 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, "_rsDataObjUnlink: acDataDeletePolicy error for %s. status = %d", dataObjUnlinkInp->objPath, status); return (status); } if (rei.status == SYS_DELETE_DISALLOWED) { rodsLog (LOG_NOTICE, "_rsDataObjUnlink:disallowed for %s via acDataDeletePolicy,stat=%d", dataObjUnlinkInp->objPath, rei.status); return (rei.status); } #endif myDataObjInfoHead = *dataObjInfoHead; if (strstr (myDataObjInfoHead->dataType, BUNDLE_STR) != NULL) { int numSubfiles; if (rsComm->proxyUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) { return CAT_INSUFFICIENT_PRIVILEGE_LEVEL; } if (getValByKey (&dataObjUnlinkInp->condInput, REPL_NUM_KW) != NULL) { return SYS_CANT_MV_BUNDLE_DATA_BY_COPY; } numSubfiles = getNumSubfilesInBunfileObj (rsComm, myDataObjInfoHead->objPath); if (numSubfiles > 0) { if (getValByKey (&dataObjUnlinkInp->condInput, EMPTY_BUNDLE_ONLY_KW) != NULL) { /* not empty. Nothing yo do */ return 0; } else { status = _unbunAndStageBunfileObj (rsComm, dataObjInfoHead, NULL, 1); if (status < 0) { /* go ahead and unlink the obj if the phy file does not * exist or have problem untaring it */ if (getErrno (status) != EEXIST && getIrodsErrno (status) != SYS_TAR_STRUCT_FILE_EXTRACT_ERR) { rodsLogError (LOG_ERROR, status, "_rsDataObjUnlink:_unbunAndStageBunfileObj err for %s", myDataObjInfoHead->objPath); return (status); } } /* dataObjInfoHead may be outdated */ *dataObjInfoHead = NULL; status = getDataObjInfoIncSpecColl (rsComm, dataObjUnlinkInp, dataObjInfoHead); if (status < 0) return (status); } } } tmpDataObjInfo = *dataObjInfoHead; while (tmpDataObjInfo != NULL) { status = dataObjUnlinkS (rsComm, dataObjUnlinkInp, tmpDataObjInfo); if (status < 0) { if (retVal == 0) { retVal = status; } } if (dataObjUnlinkInp->specColl != NULL) /* do only one */ break; tmpDataObjInfo = tmpDataObjInfo->next; } if ((*dataObjInfoHead)->specColl == NULL) resolveDataObjReplStatus (rsComm, dataObjUnlinkInp); return (retVal); }