int RodsConnection::removeObj(const std::string &objPath)
{
dataObjInp_t theObj;
int status = 0;
// sanity check, input argument string must be nonempty and begin with /
if (objPath.empty() || objPath.find_first_of('/') != 0)
return (-1);
this->mutexLock();
// initialize rods api struct
memset(&theObj, 0, sizeof (dataObjInp_t));
rstrcpy(theObj.objPath, objPath.c_str(), MAX_NAME_LEN);
// initialize remove params
addKeyVal(&theObj.condInput, FORCE_FLAG_KW, "");
// call for rods api to remove data object
status = rcDataObjUnlink(this->rodsCommPtr, &theObj);
this->mutexUnlock();
// return status to caller
return (status);
}
int
irodsUnlink (const char *path)
{
dataObjInp_t dataObjInp;
int status;
iFuseConn_t *iFuseConn = NULL;
rodsLog (LOG_DEBUG, "irodsUnlink: %s", path);
memset (&dataObjInp, 0, sizeof (dataObjInp));
status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv,
dataObjInp.objPath);
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"irodsUnlink: parseRodsPathStr of %s error", path);
/* use ENOTDIR for this type of error */
return -ENOTDIR;
}
addKeyVal (&dataObjInp.condInput, FORCE_FLAG_KW, "");
getAndUseIFuseConn (&iFuseConn, &MyRodsEnv);
status = rcDataObjUnlink (iFuseConn->conn, &dataObjInp);
if (status >= 0) {
#ifdef CACHE_FUSE_PATH
pathNotExist ((char *) path);
#endif
status = 0;
} else {
if (isReadMsgError (status)) {
ifuseReconnect (iFuseConn);
status = rcDataObjUnlink (iFuseConn->conn, &dataObjInp);
}
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"irodsUnlink: rcDataObjUnlink of %s error", path);
status = -ENOENT;
}
}
unuseIFuseConn (iFuseConn);
clearKeyVal (&dataObjInp.condInput);
return (status);
}
int irods_reli_unlink( const char *host, const char *path )
{
dataObjInp_t request;
int result;
/*
Note that an irods Unlink will fail silently if you
attempt to remove a directory. So, first we must
examine the type and fail explicitly if it is a dir.
*/
struct pfs_stat info;
result = irods_reli_stat(host,path,&info);
if(result<0) return result;
if(S_ISDIR(info.st_mode)) {
errno = EISDIR;
return -1;
}
struct irods_server *server = connect_to_host(host);
if(!server) return -1;
memset(&request,0,sizeof(request));
strcpy(request.objPath,path);
addKeyVal (&request.condInput, FORCE_FLAG_KW, "");
debug(D_IRODS,"rcUnlink %s %s",host,path);
result = rcDataObjUnlink(server->conn,&request);
debug(D_IRODS,"= %d",result);
clearKeyVal (&request.condInput);
if(result<0) {
errno = irods_reli_errno(result);
return -1;
}
return result;
}
int
irodsRename (const char *from, const char *to)
{
dataObjCopyInp_t dataObjRenameInp;
int status;
iFuseConn_t *iFuseConn = NULL;
rodsLog (LOG_DEBUG, "irodsRename: %s to %s", from, to);
/* test rcDataObjRename */
memset (&dataObjRenameInp, 0, sizeof (dataObjRenameInp));
status = parseRodsPathStr ((char *) (from + 1) , &MyRodsEnv,
dataObjRenameInp.srcDataObjInp.objPath);
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"irodsRename: parseRodsPathStr of %s error", from);
/* use ENOTDIR for this type of error */
return -ENOTDIR;
}
status = parseRodsPathStr ((char *) (to + 1) , &MyRodsEnv,
dataObjRenameInp.destDataObjInp.objPath);
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"irodsRename: parseRodsPathStr of %s error", to);
/* use ENOTDIR for this type of error */
return -ENOTDIR;
}
char *toIrodsPath = strdup(dataObjRenameInp.destDataObjInp.objPath);
addKeyVal (&dataObjRenameInp.destDataObjInp.condInput, FORCE_FLAG_KW, "");
dataObjRenameInp.srcDataObjInp.oprType =
dataObjRenameInp.destDataObjInp.oprType = RENAME_UNKNOWN_TYPE;
getAndUseIFuseConn (&iFuseConn, &MyRodsEnv);
/* rodsLog (LOG_ERROR, "irodsRenme: %s -> %s conn: %p", from, to, iFuseConn);*/
status = rcDataObjRename (iFuseConn->conn, &dataObjRenameInp);
if (status == CAT_NAME_EXISTS_AS_DATAOBJ ||
status == SYS_DEST_SPEC_COLL_SUB_EXIST) {
rcDataObjUnlink (iFuseConn->conn, &dataObjRenameInp.destDataObjInp);
status = rcDataObjRename (iFuseConn->conn, &dataObjRenameInp);
}
if (status >= 0) {
#ifdef CACHE_FUSE_PATH
status = renmeLocalPath ((char *) from, (char *) to, (char *) toIrodsPath);
#endif
} else {
if (isReadMsgError (status)) {
ifuseReconnect (iFuseConn);
status = rcDataObjRename (iFuseConn->conn, &dataObjRenameInp);
}
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"irodsRename: rcDataObjRename of %s to %s error", from, to);
status = -ENOENT;
}
}
unuseIFuseConn (iFuseConn);
free(toIrodsPath);
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
main(int argc, char **argv)
{
rcComm_t *conn;
rodsEnv myRodsEnv;
rErrMsg_t errMsg;
int status;
dataObjInp_t dataObjOpenInp;
ruleExecDelInp_t ruleExecDelInp;
if (argc != 2) {
fprintf(stderr, "Usage: %s rods_dataObj\n",argv[0]);
exit(1);
}
memset (&errMsg, 0, sizeof (rErrMsg_t));
status = getRodsEnv (&myRodsEnv);
if (status < 0) {
fprintf (stderr, "getRodsEnv error, status = %d\n", status);
exit (1);
}
conn = rcConnect (myRodsEnv.rodsHost, myRodsEnv.rodsPort, USER_NAME,
RODS_ZONE, 0, &errMsg);
if (conn == NULL) {
fprintf (stderr, "rcConnect error\n");
exit (1);
}
status = clientLogin(conn);
if (status != 0) {
rcDisconnect(conn);
exit (7);
}
/* test rcRuleExecDel call */
memset (&ruleExecDelInp, 0, sizeof (ruleExecDelInp));
snprintf (ruleExecDelInp.ruleExecId, NAME_LEN, "%s", argv[1]);
status = rcRuleExecDel (conn, &ruleExecDelInp);
if (status < 0) {
fprintf (stderr, "ruleExecDelInp of %s error. status = %d\n",
argv[1], status);
rcDisconnect (conn);
exit (1);
} else {
printf ("ruleExecDelInp: status = %d\n", status);
}
/* test rcDataObjUnlink call */
memset (&dataObjOpenInp, 0, sizeof (dataObjOpenInp));
snprintf (dataObjOpenInp.objPath, MAX_NAME_LEN, "%s/%s",
myRodsEnv.rodsCwd, argv[1]);
status = rcDataObjUnlink (conn, &dataObjOpenInp);
if (status < 0) {
fprintf (stderr, "rcDataObjUnlink error. status = %d\n", status);
rcDisconnect (conn);
exit (1);
} else {
printf ("rcDataObjUnlink: status = %d\n", status);
}
rcDisconnect (conn);
}
