int
chksumDataObjUtil (rcComm_t *conn, char *srcPath,
rodsEnv *myRodsEnv, rodsArguments_t *rodsArgs,
dataObjInp_t *dataObjInp)
{
int status;
struct timeval startTime, endTime;
char *chksumStr = NULL;
char myDir[MAX_NAME_LEN], myFile[MAX_NAME_LEN];
if (srcPath == NULL) {
rodsLog (LOG_ERROR,
"chksumDataObjUtil: NULL srcPath input");
return (USER__NULL_INPUT_ERR);
}
if (rodsArgs->verbose == True) {
(void) gettimeofday(&startTime, (struct timezone *)0);
}
rstrcpy (dataObjInp->objPath, srcPath, MAX_NAME_LEN);
status = rcDataObjChksum (conn, dataObjInp, &chksumStr);
if (status < 0) {
#if 0
if (status == CAT_NO_ROWS_FOUND && rodsArgs->resource == True) {
if (rodsArgs->verbose == True) {
printf ("%s does not exist in resource %s\n",
dataObjInp->objPath, rodsArgs->resourceString);
}
return 0;
} else {
#endif
ChksumCnt++;
FailedChksumCnt++;
rodsLogError (LOG_ERROR, status,
"chksumDataObjUtil: rcDataObjChksum error for %s",
dataObjInp->objPath);
return status;
#if 0
}
#endif
} else {
ChksumCnt++;
}
splitPathByKey (dataObjInp->objPath, myDir, myFile, '/');
if (rodsArgs->silent == False) {
printf (" %-30.30s %s\n", myFile, chksumStr);
free (chksumStr);
if (rodsArgs->verbose == True) {
(void) gettimeofday(&endTime, (struct timezone *)0);
printTiming (conn, dataObjInp->objPath, -1, NULL,
&startTime, &endTime);
}
}
return (status);
}
int
mkDirForFilePath(
rsComm_t * rsComm,
size_t startDirLen,
const std::string& filePath,
const std::string& hier,
int mode ) {
int status;
char myDir[MAX_NAME_LEN], myFile[MAX_NAME_LEN];
if ( ( status = splitPathByKey( filePath.c_str(), myDir, MAX_NAME_LEN, myFile, MAX_NAME_LEN, '/' ) ) < 0 ) {
rodsLog( LOG_NOTICE,
"mkDirForFilePath: splitPathByKey for %s error, status = %d",
filePath.c_str(), status );
return status;
}
status = mkFileDirR( rsComm, startDirLen, myDir, hier, mode );
if ( status < 0 ) {
rodsLog( LOG_ERROR, "mkFileDirR failed in mkDirForFilePath with status %d", status );
}
return status;
}
int
makeDirs(const char *path) {
char dir[MAX_NAME_LEN];
char file[MAX_NAME_LEN];
int status;
rodsLog (LOG_DEBUG, "makeDirs: %s", path);
if (path == NULL) {
rodsLog (LOG_ERROR, "makeDirs: input path is NULL");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
splitPathByKey ((char *) path, dir, file, '/');
if(isDirectory(dir) < 0) {
// parent not exist
// call recursively
status = makeDirs(dir);
if(status < 0) {
return (status);
}
}
// parent now exist
status = mkdir(path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
if(status == -EEXIST) {
return (0);
}
return status;
}
int
initReiWithCollInp (ruleExecInfo_t *rei, rsComm_t *rsComm,
collInp_t *collCreateInp, collInfo_t *collInfo)
{
int status;
memset (rei, 0, sizeof (ruleExecInfo_t));
memset (collInfo, 0, sizeof (collInfo_t));
rei->coi = collInfo;
/* try to fill out as much info in collInfo as possible */
if ((status = splitPathByKey (collCreateInp->collName,
collInfo->collParentName, collInfo->collName, '/')) < 0) {
rodsLog (LOG_ERROR,
"initReiWithCollInp: splitPathByKey for %s error, status = %d",
collCreateInp->collName, status);
return status;
} else {
rstrcpy (collInfo->collName, collCreateInp->collName, MAX_NAME_LEN);
}
rei->rsComm = rsComm;
if (rsComm != NULL) {
rei->uoic = &rsComm->clientUser;
rei->uoip = &rsComm->proxyUser;
}
return (0);
}
int
checkPermitForDataObject( rsComm_t *rsComm, char *objName, int userId, int operId ) {
genQueryInp_t genQueryInp;
genQueryOut_t *genQueryOut = NULL;
char t1[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds
char t11[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds
char t2[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds
char t3[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds
char logicalEndName[MAX_NAME_LEN];
char logicalParentDirName[MAX_NAME_LEN];
int status;
splitPathByKey( objName, logicalParentDirName, MAX_NAME_LEN, logicalEndName, MAX_NAME_LEN, '/' );
snprintf( t1, MAX_NAME_LEN, " = '%s'", logicalEndName );
snprintf( t11, MAX_NAME_LEN, " = '%s'", logicalParentDirName );
snprintf( t2, MAX_NAME_LEN, " = '%i'", userId );
snprintf( t3, MAX_NAME_LEN, " >= '%i' ", operId );
memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );
addInxIval( &genQueryInp.selectInp, COL_D_DATA_ID, 1 );
addInxVal( &genQueryInp.sqlCondInp, COL_DATA_NAME, t1 );
addInxVal( &genQueryInp.sqlCondInp, COL_COLL_NAME, t11 );
addInxVal( &genQueryInp.sqlCondInp, COL_DATA_ACCESS_USER_ID, t2 );
addInxVal( &genQueryInp.sqlCondInp, COL_DATA_ACCESS_TYPE, t3 );
genQueryInp.maxRows = 2;
status = rsGenQuery( rsComm, &genQueryInp, &genQueryOut );
freeGenQueryOut( &genQueryOut );
clearGenQueryInp( &genQueryInp );
if ( status >= 0 ) {
return 1;
}
else {
return 0;
}
}
/**
* \fn rcExecMyRule( rcComm_t *conn, execMyRuleInp_t *execMyRuleInp, msParamArray_t **outParamArray )
*
* \brief Execute my rule.
*
* \user client
*
* \ingroup rules
*
* \since 1.0
*
*
* \remark none
*
* \note none
*
* \param[in] conn - A rcComm_t connection handle to the server.
* \param[in] execMyRuleInp
* \param[out] outParamArray
*
* \return integer
* \retval 0 on success.
* \sideeffect none
* \pre none
* \post none
* \sa none
**/
int
rcExecMyRule( rcComm_t *conn, execMyRuleInp_t *execMyRuleInp,
msParamArray_t **outParamArray ) {
int status = procApiRequest( conn, EXEC_MY_RULE_AN, execMyRuleInp, NULL,
( void ** )outParamArray, NULL );
while ( status == SYS_SVR_TO_CLI_MSI_REQUEST ) {
/* it is a server request */
msParam_t *myParam = NULL, *putParam = NULL;
if ( ( myParam = putParam = getMsParamByLabel( *outParamArray, CL_PUT_ACTION ) ) ||
( myParam = getMsParamByLabel( *outParamArray, CL_GET_ACTION ) ) ) {
//putParam is non-null if it's a put, null if it's a get
dataObjInp_t * dataObjInp = ( dataObjInp_t * ) myParam->inOutStruct;
char * locFilePath;
char myDir[MAX_NAME_LEN], myFile[MAX_NAME_LEN];
// locFilePath should be the return of getValByKey if it exists,
// otherwise use the filename from splitPathByKey
if ( ( locFilePath = getValByKey( &dataObjInp->condInput, LOCAL_PATH_KW ) ) ||
( ( status = splitPathByKey( dataObjInp->objPath, myDir, MAX_NAME_LEN, myFile, MAX_NAME_LEN, '/' ) ) >= 0 &&
( locFilePath = ( char * ) myFile ) ) ) {
status = putParam ?
rcDataObjPut( conn, dataObjInp, locFilePath ) :
rcDataObjGet( conn, dataObjInp, locFilePath );
rcOprComplete( conn, status );
}
else {
rodsLogError( LOG_ERROR, status,
"rcExecMyRule: splitPathByKey for %s error",
dataObjInp->objPath );
rcOprComplete( conn, USER_FILE_DOES_NOT_EXIST );
}
clearKeyVal( &dataObjInp->condInput );
}
else {
rcOprComplete( conn, SYS_SVR_TO_CLI_MSI_NO_EXIST );
}
/* free outParamArray */
clearMsParamArray( *outParamArray, 1 );
free( *outParamArray );
*outParamArray = NULL;
/* read the reply from the earlier call */
status = branchReadAndProcApiReply( conn, EXEC_MY_RULE_AN,
( void ** )outParamArray, NULL );
if ( status < 0 ) {
rodsLogError( LOG_DEBUG, status,
"rcExecMyRule: readAndProcApiReply failed. status = %d",
status );
}
}
return status;
}
int
getLastPathElement( char *inInPath, char *lastElement ) {
char mydir[MAX_NAME_LEN];
char inPath[MAX_NAME_LEN];
int len;
char *tmpPtr1, *tmpPtr2;
if ( inInPath == NULL ) {
*lastElement = '\0';
return ( 0 );
}
strcpy( inPath, inInPath );
#ifdef windows_platform
iRODSNtPathForwardSlash( inPath );
#endif
splitPathByKey( inPath, mydir, lastElement, '/' );
len = strlen( lastElement );
if ( len == 0 ) {
len = strlen( inPath );
if ( len == 0 ) {
*lastElement = '\0';
return ( 0 );
}
else {
rstrcpy( lastElement, inPath, MAX_NAME_LEN );
len = strlen( lastElement );
}
}
tmpPtr1 = lastElement + len;
if ( len >= 2 ) {
tmpPtr2 = tmpPtr1 - 2;
if ( strcmp( tmpPtr2, "/." ) == 0 || strcmp( tmpPtr2, ".." ) == 0 ) {
*tmpPtr2 = '\0';
return 0;
}
}
if ( len >= 1 ) {
tmpPtr2 = tmpPtr1 - 1;
if ( *tmpPtr2 == '.' || *tmpPtr2 == '~' ||
*tmpPtr2 == '^' || *tmpPtr2 == '/' ) {
*tmpPtr2 = '\0';
return 0;
}
}
return ( 0 );
}
int
getParentDir(const char *path, char *parent) {
char dir[MAX_NAME_LEN], file[MAX_NAME_LEN];
if (path == NULL) {
rodsLog (LOG_ERROR, "getParentDir: input path is NULL");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
splitPathByKey ((char*) path, dir, file, '/');
rstrcpy (parent, dir, MAX_NAME_LEN);
return (0);
}
int
isData(rsComm_t *rsComm, char *objName, rodsLong_t *dataId) {
char logicalEndName[MAX_NAME_LEN]{};
char logicalParentDirName[MAX_NAME_LEN]{};
auto status{splitPathByKey(objName, logicalParentDirName, MAX_NAME_LEN, logicalEndName, MAX_NAME_LEN, '/')};
if (status < 0) {
const auto err{ERROR(status,
(boost::format("splitPathByKey failed for [%s]") %
objName).str().c_str())};
irods::log(err);
return err.code();
}
genQueryInp_t genQueryInp{};
genQueryOut_t *genQueryOut{};
char tmpStr[MAX_NAME_LEN]{};
memset(&genQueryInp, 0, sizeof(genQueryInp_t));
snprintf(tmpStr, MAX_NAME_LEN, "='%s'", logicalEndName);
addInxVal(&genQueryInp.sqlCondInp, COL_DATA_NAME, tmpStr);
addInxIval(&genQueryInp.selectInp, COL_D_DATA_ID, 1);
snprintf(tmpStr, MAX_NAME_LEN, "='%s'", logicalParentDirName);
addInxVal(&genQueryInp.sqlCondInp, COL_COLL_NAME, tmpStr);
addInxIval(&genQueryInp.selectInp, COL_COLL_ID, 1);
genQueryInp.maxRows = 2;
status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
if (status < 0) {
freeGenQueryOut(&genQueryOut);
clearGenQueryInp(&genQueryInp);
return status;
}
sqlResult_t *dataIdRes{getSqlResultByInx(genQueryOut, COL_D_DATA_ID)};
if (NULL == dataIdRes) {
const auto err{ERROR(UNMATCHED_KEY_OR_INDEX, "getSqlResultByInx for COL_D_DATA_ID failed")};
irods::log(err);
return err.code();
}
if (NULL != dataId) {
*dataId = strtoll(dataIdRes->value, 0, 0);
}
freeGenQueryOut(&genQueryOut);
clearGenQueryInp(&genQueryInp);
return status;
}
int
lsDataObjUtilLong (rcComm_t *conn, char *srcPath, rodsEnv *myRodsEnv,
rodsArguments_t *rodsArgs, genQueryInp_t *genQueryInp)
{
int status;
genQueryOut_t *genQueryOut = NULL;
char myColl[MAX_NAME_LEN], myData[MAX_NAME_LEN];
char condStr[MAX_NAME_LEN];
int queryFlags;
queryFlags = setQueryFlag (rodsArgs);
setQueryInpForData (queryFlags, genQueryInp);
genQueryInp->maxRows = MAX_SQL_ROWS;
memset (myColl, 0, MAX_NAME_LEN);
memset (myData, 0, MAX_NAME_LEN);
if ((status = splitPathByKey (
srcPath, myColl, myData, '/')) < 0) {
rodsLogError (LOG_ERROR, status,
"setQueryInpForLong: splitPathByKey for %s error, status = %d",
srcPath, status);
return (status);
}
snprintf (condStr, MAX_NAME_LEN, "='%s'", myColl);
addInxVal (&genQueryInp->sqlCondInp, COL_COLL_NAME, condStr);
snprintf (condStr, MAX_NAME_LEN, "='%s'", myData);
addInxVal (&genQueryInp->sqlCondInp, COL_DATA_NAME, condStr);
status = rcGenQuery (conn, genQueryInp, &genQueryOut);
if (status < 0) {
if (status == CAT_NO_ROWS_FOUND) {
rodsLog (LOG_ERROR, "%s does not exist or user lacks access permission",
srcPath);
} else {
rodsLogError (LOG_ERROR, status,
"lsDataObjUtilLong: rcGenQuery error for %s", srcPath);
}
return (status);
}
printLsLong (conn, rodsArgs, genQueryOut);
return (0);
}
int
prepareDir(const char *path) {
int status;
char dir[MAX_NAME_LEN], file[MAX_NAME_LEN];
if (path == NULL) {
rodsLog (LOG_ERROR, "prepareDir: input path is NULL");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
splitPathByKey ((char *) path, dir, file, '/');
// make dirs
status = makeDirs(dir);
return status;
}
int
setTDSUrl (tdsDirStruct_t *tdsDirStruct, char *urlPath, int isDir)
{
int inx;
char *tmpPtr, *outurl;
int status;
inx = allocTdsUrlPath (tdsDirStruct);
if (inx < 0) return inx;
if (isDir == True) {
tdsDirStruct->urlPath[inx].st_mode = S_IFDIR;
} else {
tdsDirStruct->urlPath[inx].st_mode = S_IFREG;
}
outurl = tdsDirStruct->urlPath[inx].path;
if (strncasecmp (urlPath, HTTP_PREFIX, strlen (HTTP_PREFIX)) == 0) {
/* a full url */
rstrcpy (outurl, urlPath, MAX_NAME_LEN);
return inx;
}
if (isDir == False) {
rstrcpy (outurl, tdsDirStruct->dirUrl, MAX_NAME_LEN);
tmpPtr = strcasestr (outurl, THREDDS_DIR);
tmpPtr += strlen (THREDDS_DIR);
snprintf (tmpPtr, MAX_NAME_LEN, "dodsC/%s", urlPath);
return inx;
}
/* a link */
if (strncasecmp (urlPath, THREDDS_DIR, strlen (THREDDS_DIR)) == 0) {
rstrcpy (outurl, tdsDirStruct->dirUrl, MAX_NAME_LEN);
tmpPtr = strcasestr (outurl, THREDDS_DIR);
/* start with /thredds/ */
if (tmpPtr == NULL) return -1;
snprintf (tmpPtr, MAX_NAME_LEN, "%s", urlPath);
return inx;
} else {
char myFile[MAX_NAME_LEN], mydir[MAX_NAME_LEN];
status = splitPathByKey (tdsDirStruct->dirUrl, mydir, myFile, '/');
if (status < 0) return status;
snprintf (outurl, MAX_NAME_LEN, "%s/%s", mydir, urlPath);
return inx;
}
}
int
mkDirForFilePath (int fileType, rsComm_t *rsComm, char *startDir,
char *filePath, int mode)
{
int status;
char myDir[MAX_NAME_LEN], myFile[MAX_NAME_LEN];
if ((status = splitPathByKey (filePath, myDir, myFile, '/')) < 0) {
rodsLog (LOG_NOTICE,
"mkDirForFilePath: splitPathByKey for %s error, status = %d",
filePath, status);
return (status);
}
status = mkFileDirR (fileType, rsComm, startDir, myDir, mode);
return (status);
}
int
getFileCachePath( const char *inPath, char *cachePath ) {
char myDir[MAX_NAME_LEN], myFile[MAX_NAME_LEN];
struct stat statbuf;
if ( inPath == NULL || cachePath == NULL ) {
rodsLog( LOG_ERROR,
"getFileCachePath: input inPath or cachePath is NULL" );
return SYS_INTERNAL_NULL_INPUT_ERR;
}
splitPathByKey( ( char * ) inPath, myDir, MAX_NAME_LEN, myFile, MAX_NAME_LEN, '/' );
while ( 1 ) {
snprintf( cachePath, MAX_NAME_LEN, "%s/%s.%d", FuseCacheDir,
myFile, ( int ) random() );
if ( stat( cachePath, &statbuf ) < 0 ) {
break;
}
}
return 0;
}
int
isData (rsComm_t *rsComm, char *objName, rodsLong_t *dataId)
{
genQueryInp_t genQueryInp;
genQueryOut_t *genQueryOut = NULL;
char tmpStr[MAX_NAME_LEN];
char logicalEndName[MAX_NAME_LEN];
char logicalParentDirName[MAX_NAME_LEN];
int status;
status = splitPathByKey(objName,
logicalParentDirName, logicalEndName, '/');
memset (&genQueryInp, 0, sizeof (genQueryInp_t));
snprintf (tmpStr, MAX_NAME_LEN, "='%s'", logicalEndName);
addInxVal (&genQueryInp.sqlCondInp, COL_DATA_NAME, tmpStr);
addInxIval (&genQueryInp.selectInp, COL_D_DATA_ID, 1);
snprintf (tmpStr, MAX_NAME_LEN, "='%s'", logicalParentDirName);
addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, tmpStr);
addInxIval (&genQueryInp.selectInp, COL_COLL_ID, 1);
genQueryInp.maxRows = 2;
status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
if (status >= 0) {
sqlResult_t *dataIdRes;
if ((dataIdRes = getSqlResultByInx (genQueryOut, COL_D_DATA_ID)) ==
NULL) {
rodsLog (LOG_ERROR,
"isData: getSqlResultByInx for COL_D_DATA_ID failed");
return (UNMATCHED_KEY_OR_INDEX);
}
if (dataId != NULL) {
*dataId = strtoll (dataIdRes->value, 0, 0);
}
freeGenQueryOut (&genQueryOut);
}
clearGenQueryInp (&genQueryInp);
return(status);
}
int
getPhyPath (rsComm_t *rsComm, char *objName, char *resource, char *phyPath)
{
genQueryInp_t genQueryInp;
genQueryOut_t *genQueryOut = NULL;
char tmpStr[MAX_NAME_LEN];
char logicalEndName[MAX_NAME_LEN];
char logicalParentDirName[MAX_NAME_LEN];
int status;
status = splitPathByKey(objName,
logicalParentDirName, logicalEndName, '/');
memset (&genQueryInp, 0, sizeof (genQueryInp_t));
snprintf (tmpStr, MAX_NAME_LEN, "='%s'", logicalEndName);
addInxVal (&genQueryInp.sqlCondInp, COL_DATA_NAME, tmpStr);
snprintf (tmpStr, MAX_NAME_LEN, "='%s'", logicalParentDirName);
addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, tmpStr);
addInxIval (&genQueryInp.selectInp, COL_D_DATA_PATH, 1);
genQueryInp.maxRows = 2;
status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
if (status >= 0) {
sqlResult_t *phyPathRes = NULL;
if ((phyPathRes = getSqlResultByInx (genQueryOut, COL_D_DATA_PATH)) ==
NULL) {
rodsLog (LOG_ERROR,
"getPhyPath: getSqlResultByInx for COL_D_DATA_PATH failed");
return (UNMATCHED_KEY_OR_INDEX);
}
if (phyPath != NULL) {
rstrcpy (phyPath, phyPathRes->value, MAX_NAME_LEN);
}
freeGenQueryOut (&genQueryOut);
}
clearGenQueryInp (&genQueryInp);
return(status);
}
/*
Via a general query and show the AVUs for a dataobject.
*/
int
showDataObj(char *name, char *attrName, int wild)
{
genQueryInp_t genQueryInp;
genQueryOut_t *genQueryOut;
int i1a[10];
int i1b[10];
int i2a[10];
char *condVal[10];
char v1[BIG_STR];
char v2[BIG_STR];
char v3[BIG_STR];
char fullName[MAX_NAME_LEN];
char myDirName[MAX_NAME_LEN];
char myFileName[MAX_NAME_LEN];
int status;
/* "id" only used in testMode, in longMode id is reset to be 'time set' :*/
char *columnNames[]={"attribute", "value", "units", "id"};
memset (&genQueryInp, 0, sizeof (genQueryInp_t));
printf("AVUs defined for dataObj %s:\n",name);
printCount=0;
i1a[0]=COL_META_DATA_ATTR_NAME;
i1b[0]=0;
i1a[1]=COL_META_DATA_ATTR_VALUE;
i1b[1]=0;
i1a[2]=COL_META_DATA_ATTR_UNITS;
i1b[2]=0;
if (testMode) {
i1a[3]=COL_META_DATA_ATTR_ID;
i1b[3]=0;
}
if (longMode) {
i1a[3]=COL_META_DATA_MODIFY_TIME;
i1b[3]=0;
columnNames[3]="time set";
}
genQueryInp.selectInp.inx = i1a;
genQueryInp.selectInp.value = i1b;
genQueryInp.selectInp.len = 3;
if (testMode) {
genQueryInp.selectInp.len = 4;
}
if (longMode) {
genQueryInp.selectInp.len = 4;
}
i2a[0]=COL_COLL_NAME;
sprintf(v1,"='%s'",cwd);
condVal[0]=v1;
i2a[1]=COL_DATA_NAME;
sprintf(v2,"='%s'",name);
condVal[1]=v2;
strncpy(fullName, cwd, MAX_NAME_LEN);
rstrcat(fullName, "/", MAX_NAME_LEN);
rstrcat(fullName, name, MAX_NAME_LEN);
if (strstr(name, "/") != NULL) {
/* reset v1 and v2 for when full path or relative path entered */
if (*name=='/') {
strncpy(fullName, name, MAX_NAME_LEN);
}
status = splitPathByKey(fullName,
myDirName, myFileName, '/');
sprintf(v1,"='%s'",myDirName);
sprintf(v2,"='%s'",myFileName);
}
genQueryInp.sqlCondInp.inx = i2a;
genQueryInp.sqlCondInp.value = condVal;
genQueryInp.sqlCondInp.len=2;
if (attrName != NULL && *attrName!='\0') {
i2a[2]=COL_META_DATA_ATTR_NAME;
if (wild) {
sprintf(v3,"like '%s'",attrName);
}
else {
sprintf(v3,"= '%s'",attrName);
}
condVal[2]=v3;
genQueryInp.sqlCondInp.len++;
}
genQueryInp.maxRows=10;
genQueryInp.continueInx=0;
genQueryInp.condInput.len=0;
if (zoneArgument[0]!='\0') {
addKeyVal (&genQueryInp.condInput, ZONE_KW, zoneArgument);
}
status = rcGenQuery(Conn, &genQueryInp, &genQueryOut);
if (status == CAT_NO_ROWS_FOUND) {
i1a[0]=COL_D_DATA_PATH;
genQueryInp.selectInp.len = 1;
status = rcGenQuery(Conn, &genQueryInp, &genQueryOut);
if (status==0) {
printf("None\n");
return(0);
}
if (status == CAT_NO_ROWS_FOUND) {
printf("Dataobject %s does not exist.\n", fullName);
return(0);
}
printGenQueryResults(Conn, status, genQueryOut, columnNames);
}
else {
printGenQueryResults(Conn, status, genQueryOut, columnNames);
}
while (status==0 && genQueryOut->continueInx > 0) {
genQueryInp.continueInx=genQueryOut->continueInx;
status = rcGenQuery(Conn, &genQueryInp, &genQueryOut);
if (genQueryOut->rowCnt>0) printf("----\n");
printGenQueryResults(Conn, status, genQueryOut,
columnNames);
}
return (0);
}
int
rsMkBundlePath( rsComm_t *rsComm, char *collection, char *bundlePath,
int myRanNum ) {
int status;
char *tmpStr;
char startBundlePath[MAX_NAME_LEN];
char destBundleColl[MAX_NAME_LEN], myFile[MAX_NAME_LEN];
char *bundlePathPtr;
bundlePathPtr = bundlePath;
*bundlePathPtr = '/';
bundlePathPtr++;
tmpStr = collection + 1;
/* copy the zone */
while ( *tmpStr != '\0' ) {
*bundlePathPtr = *tmpStr;
bundlePathPtr ++;
if ( *tmpStr == '/' ) {
tmpStr ++;
break;
}
tmpStr ++;
}
if ( *tmpStr == '\0' ) {
rodsLog( LOG_ERROR,
"rsMkBundlePath: input path %s too short", collection );
return USER_INPUT_PATH_ERR;
}
/* cannot bundle trash and bundle */
if ( strncmp( tmpStr, "trash/", 6 ) == 0 ||
strncmp( tmpStr, "bundle/", 7 ) == 0 ) {
rodsLog( LOG_ERROR,
"rsMkBundlePath: cannot bundle trash or bundle path %s", collection );
return USER_INPUT_PATH_ERR;
}
/* don't want to go back beyond /myZone/bundle/home */
*bundlePathPtr = '\0';
rstrcpy( startBundlePath, bundlePath, MAX_NAME_LEN );
snprintf( bundlePathPtr, MAX_NAME_LEN, "bundle/%s.%u", tmpStr, ( unsigned int )myRanNum );
if ( ( status = splitPathByKey( bundlePath, destBundleColl, MAX_NAME_LEN, myFile, MAX_NAME_LEN, '/' ) )
< 0 ) {
rodsLog( LOG_ERROR,
"rsMkBundlePath: splitPathByKey error for %s ", bundlePath );
return USER_INPUT_PATH_ERR;
}
status = rsMkCollR( rsComm, startBundlePath, destBundleColl );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"rsMkBundlePath: rsMkCollR error for startPath %s, destPath %s ",
startBundlePath, destBundleColl );
}
return status;
}
int
cpCollUtil( rcComm_t *conn, char *srcColl, char *targColl,
rodsEnv *myRodsEnv, rodsArguments_t *rodsArgs,
dataObjCopyInp_t *dataObjCopyInp, rodsRestart_t *rodsRestart ) {
int status = 0;
int savedStatus = 0;
char parPath[MAX_NAME_LEN], childPath[MAX_NAME_LEN];
collHandle_t collHandle;
collEnt_t collEnt;
char srcChildPath[MAX_NAME_LEN], targChildPath[MAX_NAME_LEN];
dataObjCopyInp_t childDataObjCopyInp;
if ( srcColl == NULL || targColl == NULL ) {
rodsLog( LOG_ERROR,
"cpCollUtil: NULL srcColl or targColl in cp" );
return USER__NULL_INPUT_ERR;
}
if ( rodsArgs->recursive != True ) {
rodsLog( LOG_ERROR,
"cpCollUtil: -r option must be used for copying %s directory",
srcColl );
return USER_INPUT_OPTION_ERR;
}
status = rclOpenCollection( conn, srcColl, 0, &collHandle );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"cpCollUtil: rclOpenCollection of %s error. status = %d",
srcColl, status );
return status;
}
while ( ( status = rclReadCollection( conn, &collHandle, &collEnt ) ) >= 0 ) {
if ( collEnt.objType == DATA_OBJ_T ) {
snprintf( srcChildPath, MAX_NAME_LEN, "%s/%s",
collEnt.collName, collEnt.dataName );
snprintf( targChildPath, MAX_NAME_LEN, "%s/%s",
targColl, collEnt.dataName );
status = chkStateForResume( conn, rodsRestart, targChildPath,
rodsArgs, DATA_OBJ_T, &dataObjCopyInp->destDataObjInp.condInput,
1 );
if ( status < 0 ) {
/* restart failed */
break;
}
else if ( status == 0 ) {
continue;
}
status = cpFileUtil( conn, srcChildPath, targChildPath,
collEnt.dataSize, rodsArgs, dataObjCopyInp );
if ( status < 0 ) {
rodsLogError( LOG_ERROR, status,
"getCollUtil: getDataObjUtil failed for %s. status = %d",
srcChildPath, status );
if ( rodsRestart->fd > 0 ) {
break;
}
else {
savedStatus = status;
}
}
else {
status = procAndWrriteRestartFile( rodsRestart, targChildPath );
}
}
else if ( collEnt.objType == COLL_OBJ_T ) {
if ( ( status = splitPathByKey(
collEnt.collName, parPath, MAX_NAME_LEN, childPath, MAX_NAME_LEN, '/' ) ) < 0 ) {
rodsLogError( LOG_ERROR, status,
"cpCollUtil:: splitPathByKey for %s error, status = %d",
collEnt.collName, status );
return status;
}
snprintf( targChildPath, MAX_NAME_LEN, "%s/%s",
targColl, childPath );
mkCollR( conn, targColl, targChildPath );
if ( rodsArgs->verbose == True ) {
fprintf( stdout, "C- %s:\n", targChildPath );
}
/* the child is a spec coll. need to drill down */
childDataObjCopyInp = *dataObjCopyInp;
if ( collEnt.specColl.collClass != NO_SPEC_COLL )
childDataObjCopyInp.srcDataObjInp.specColl =
&collEnt.specColl;
status = cpCollUtil( conn, collEnt.collName,
targChildPath, myRodsEnv, rodsArgs, &childDataObjCopyInp,
rodsRestart );
if ( status < 0 && status != CAT_NO_ROWS_FOUND &&
status != SYS_SPEC_COLL_OBJ_NOT_EXIST ) {
savedStatus = status;
}
}
}
rclCloseCollection( &collHandle );
if ( savedStatus < 0 ) {
return savedStatus;
}
else if ( status == CAT_NO_ROWS_FOUND ||
status == SYS_SPEC_COLL_OBJ_NOT_EXIST ) {
return 0;
}
else {
return status;
}
}
int
rsDataObjCopy( rsComm_t *rsComm, dataObjCopyInp_t *dataObjCopyInp,
transferStat_t **transStat ) {
dataObjInp_t *srcDataObjInp, *destDataObjInp;
int srcL1descInx, destL1descInx;
int status;
int existFlag;
uint createMode;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
srcDataObjInp = &dataObjCopyInp->srcDataObjInp;
destDataObjInp = &dataObjCopyInp->destDataObjInp;
resolveLinkedPath( rsComm, srcDataObjInp->objPath, &specCollCache, &srcDataObjInp->condInput );
resolveLinkedPath( rsComm, destDataObjInp->objPath, &specCollCache, &destDataObjInp->condInput );
remoteFlag = getAndConnRemoteZoneForCopy( rsComm, dataObjCopyInp, &rodsServerHost );
if ( remoteFlag < 0 ) {
return remoteFlag;
}
else if ( remoteFlag == REMOTE_HOST ) {
status = _rcDataObjCopy( rodsServerHost->conn, dataObjCopyInp,
transStat );
return status;
}
if ( strcmp( srcDataObjInp->objPath, destDataObjInp->objPath ) == 0 ) {
rodsLog( LOG_ERROR,
"rsDataObjCopy: same src and dest objPath %s not allowed",
srcDataObjInp->objPath );
return USER_INPUT_PATH_ERR;
}
addKeyVal( &srcDataObjInp->condInput, PHYOPEN_BY_SIZE_KW, "" );
srcL1descInx = rsDataObjOpen( rsComm, srcDataObjInp );
if ( srcL1descInx < 0 ) {
std::stringstream msg;
char* sys_error = NULL;
const char* rods_error = rodsErrorName( srcL1descInx, &sys_error );
msg << __FUNCTION__;
msg << " - Failed to open source object: \"";
msg << srcDataObjInp->objPath;
msg << "\" - ";
msg << rods_error << " " << sys_error;
irods::log( LOG_ERROR, msg.str() );
free( sys_error );
return srcL1descInx;
}
/* have to set L1desc[srcL1descInx].dataSize because open set this to -1 */
destDataObjInp->dataSize = L1desc[srcL1descInx].dataSize =
L1desc[srcL1descInx].dataObjInfo->dataSize;
createMode = atoi( L1desc[srcL1descInx].dataObjInfo->dataMode );
if ( createMode >= 0100 ) {
destDataObjInp->createMode = createMode;
}
L1desc[srcL1descInx].oprType = COPY_SRC;
if ( L1desc[srcL1descInx].l3descInx <= 2 ) {
/* dataSingleBuf */
addKeyVal( &destDataObjInp->condInput, NO_OPEN_FLAG_KW, "" );
}
destL1descInx = rsDataObjCreate( rsComm, destDataObjInp );
if ( destL1descInx == CAT_UNKNOWN_COLLECTION ) {
/* collection does not exist. make one */
char parColl[MAX_NAME_LEN], child[MAX_NAME_LEN];
splitPathByKey( destDataObjInp->objPath, parColl, MAX_NAME_LEN, child, MAX_NAME_LEN, '/' );
rsMkCollR( rsComm, "/", parColl );
destL1descInx = rsDataObjCreate( rsComm, destDataObjInp );
}
if ( destL1descInx < 0 ) {
clearKeyVal( &destDataObjInp->condInput );
std::stringstream msg;
char* sys_error = NULL;
const char* rods_error = rodsErrorName( destL1descInx, &sys_error );
msg << __FUNCTION__;
msg << " - Failed to create destination object: \"";
msg << destDataObjInp->objPath;
msg << "\" - ";
msg << rods_error << " " << sys_error;
irods::log( LOG_ERROR, msg.str() );
free( sys_error );
return destL1descInx;
}
if ( L1desc[destL1descInx].replStatus == NEWLY_CREATED_COPY ) {
existFlag = 0;
}
else {
existFlag = 1;
}
L1desc[destL1descInx].oprType = COPY_DEST;
L1desc[destL1descInx].srcL1descInx = srcL1descInx;
rstrcpy( L1desc[destL1descInx].dataObjInfo->dataType,
L1desc[srcL1descInx].dataObjInfo->dataType, NAME_LEN );
/* set dataSize for verification in _rsDataObjClose */
L1desc[destL1descInx].dataSize =
L1desc[srcL1descInx].dataObjInfo->dataSize;
status = _rsDataObjCopy( rsComm, destL1descInx, existFlag, transStat );
clearKeyVal( &destDataObjInp->condInput );
return status;
}
int
_rsDataObjCopy( rsComm_t *rsComm, int destL1descInx, int existFlag,
transferStat_t **transStat ) {
dataObjInp_t *srcDataObjInp, *destDataObjInp;
openedDataObjInp_t dataObjCloseInp;
dataObjInfo_t *srcDataObjInfo, *destDataObjInfo;
int srcL1descInx;
int status = 0, status2;
destDataObjInp = L1desc[destL1descInx].dataObjInp;
destDataObjInfo = L1desc[destL1descInx].dataObjInfo;
srcL1descInx = L1desc[destL1descInx].srcL1descInx;
srcDataObjInp = L1desc[srcL1descInx].dataObjInp;
srcDataObjInfo = L1desc[srcL1descInx].dataObjInfo;
if ( destDataObjInp == NULL ) { // JMC cppcheck - null ptr ref
rodsLog( LOG_ERROR, "_rsDataObjCopy: :: destDataObjInp is NULL" );
return -1;
}
if ( destDataObjInfo == NULL ) { // JMC cppcheck - null ptr ref
rodsLog( LOG_ERROR, "_rsDataObjCopy: :: destDataObjInfo is NULL" );
return -1;
}
if ( srcDataObjInp == NULL ) { // JMC cppcheck - null ptr ref
rodsLog( LOG_ERROR, "_rsDataObjCopy: :: srcDataObjInp is NULL" );
return -1;
}
if ( srcDataObjInfo == NULL ) { // JMC cppcheck - null ptr ref
rodsLog( LOG_ERROR, "_rsDataObjCopy: :: srcDataObjInfo is NULL" );
return -1;
}
if ( L1desc[srcL1descInx].l3descInx <= 2 ) {
/* no physical file was opened */
status = l3DataCopySingleBuf( rsComm, destL1descInx );
/* has not been registered yet because of NO_OPEN_FLAG_KW */
if ( status >= 0 &&
existFlag == 0 &&
destDataObjInfo->specColl == NULL &&
L1desc[destL1descInx].remoteZoneHost == NULL ) {
/* If the dest is in remote zone, register in _rsDataObjClose there */
status = svrRegDataObj( rsComm, destDataObjInfo );
if ( status == CAT_UNKNOWN_COLLECTION ) {
/* collection does not exist. make one */
char parColl[MAX_NAME_LEN], child[MAX_NAME_LEN];
splitPathByKey( destDataObjInfo->objPath, parColl, MAX_NAME_LEN, child, MAX_NAME_LEN, '/' );
status = svrRegDataObj( rsComm, destDataObjInfo );
rsMkCollR( rsComm, "/", parColl );
status = svrRegDataObj( rsComm, destDataObjInfo );
}
if ( status < 0 ) {
rodsLog( LOG_NOTICE,
"_rsDataObjCopy: svrRegDataObj for %s failed, status = %d",
destDataObjInfo->objPath, status );
return status;
}
}
}
else {
if ( srcDataObjInfo != NULL ) {
destDataObjInp->numThreads = getNumThreads( rsComm, srcDataObjInfo->dataSize, destDataObjInp->numThreads, NULL,
destDataObjInfo->rescHier, srcDataObjInfo->rescHier, 0 );
}
srcDataObjInp->numThreads = destDataObjInp->numThreads;
status = dataObjCopy( rsComm, destL1descInx );
}
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = destL1descInx;
if ( status >= 0 ) {
*transStat = ( transferStat_t* )malloc( sizeof( transferStat_t ) );
memset( *transStat, 0, sizeof( transferStat_t ) );
( *transStat )->bytesWritten = srcDataObjInfo->dataSize;
( *transStat )->numThreads = destDataObjInp->numThreads;
dataObjCloseInp.bytesWritten = srcDataObjInfo->dataSize;
}
status2 = rsDataObjClose( rsComm, &dataObjCloseInp );
if ( status ) {
return status;
}
return status2;
}
/* perform the ls command */
int
doLs(rcComm_t *Conn, char *objPath, int longOption) {
genQueryInp_t genQueryInp;
genQueryOut_t *genQueryOut;
int i1a[30];
int i1b[30]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int i2a[30];
char *condVal[10];
char v1[MAX_NAME_LEN+10];
char v2[MAX_NAME_LEN+10];
int i, status;
int printCount;
char *columnNames[]={
"data_name",
"data_id", "coll_id", "data_repl_num", "data_version",
"data_type_name", "data_size", "resc_group_name", "resc_name",
"data_path ", "data_owner_name", "data_owner_zone",
"data_repl_status", "data_status",
"data_checksum ", "data_expiry_ts (expire time)",
"data_map_id", "r_comment", "create_ts","modify_ts"};
char logicalEndName[MAX_NAME_LEN];
char logicalParentDirName[MAX_NAME_LEN];
memset (&genQueryInp, 0, sizeof (genQueryInp_t));
printCount=0;
printf("doing ls of %s\n", objPath);
status = splitPathByKey(objPath,
logicalParentDirName, logicalEndName, '/');
i=0;
i1a[i++]=COL_DATA_NAME;
if (longOption) {
i1a[i++]=COL_D_DATA_ID;
i1a[i++]=COL_D_COLL_ID;
i1a[i++]=COL_DATA_REPL_NUM;
i1a[i++]=COL_DATA_VERSION;
i1a[i++]=COL_DATA_TYPE_NAME;
i1a[i++]=COL_DATA_SIZE;
i1a[i++]=COL_D_RESC_GROUP_NAME;
i1a[i++]=COL_D_RESC_NAME;
i1a[i++]=COL_D_DATA_PATH;
i1a[i++]=COL_D_OWNER_NAME;
i1a[i++]=COL_D_OWNER_ZONE;
i1a[i++]=COL_D_REPL_STATUS;
i1a[i++]=COL_D_DATA_STATUS;
i1a[i++]=COL_D_DATA_CHECKSUM;
i1a[i++]=COL_D_EXPIRY;
i1a[i++]=COL_D_MAP_ID;
i1a[i++]=COL_D_COMMENTS;
i1a[i++]=COL_D_CREATE_TIME;
i1a[i++]=COL_D_MODIFY_TIME;
}
else {
columnNames[1]="data_expiry_ts (expire time)";
i1a[i++]=COL_D_EXPIRY;
}
genQueryInp.selectInp.inx = i1a;
genQueryInp.selectInp.value = i1b;
genQueryInp.selectInp.len = i;
genQueryInp.sqlCondInp.inx = i2a;
genQueryInp.sqlCondInp.value = condVal;
i2a[0]=COL_COLL_NAME;
snprintf(v1,sizeof(v1),"='%s'",logicalParentDirName);
condVal[0]=v1;
i2a[1]=COL_DATA_NAME;
snprintf(v2,sizeof(v1),"='%s'",logicalEndName);
condVal[1]=v2;
genQueryInp.sqlCondInp.len=2;
genQueryInp.maxRows=50;
genQueryInp.continueInx=0;
status = rcGenQuery(Conn, &genQueryInp, &genQueryOut);
if (status == CAT_NO_ROWS_FOUND) {
i1a[0]=COL_R_RESC_INFO;
genQueryInp.selectInp.len = 1;
status = rcGenQuery(Conn, &genQueryInp, &genQueryOut);
if (status==0) {
printf("None\n");
return(0);
}
if (status == CAT_NO_ROWS_FOUND) {
printf("DataObject %s does not exist.\n", objPath);
return(0);
}
}
printCount+= printGenQueryResults(Conn, status, genQueryOut, columnNames,
longOption);
while (status==0 && genQueryOut->continueInx > 0) {
genQueryInp.continueInx=genQueryOut->continueInx;
status = rcGenQuery(Conn, &genQueryInp, &genQueryOut);
if (genQueryOut->rowCnt > 0 && longOption) {
printf("----\n");
}
printCount+= printGenQueryResults(Conn, status, genQueryOut,
columnNames, longOption);
}
return (1);
}
int
dataObjStat (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
rodsObjStat_t **rodsObjStatOut)
{
genQueryInp_t genQueryInp;
genQueryOut_t *genQueryOut = NULL;
int status;
char myColl[MAX_NAME_LEN], myData[MAX_NAME_LEN];
char condStr[MAX_NAME_LEN];
sqlResult_t *dataSize;
sqlResult_t *dataMode;
sqlResult_t *replStatus;
sqlResult_t *dataId;
sqlResult_t *chksum;
sqlResult_t *ownerName;
sqlResult_t *ownerZone;
sqlResult_t *createTime;
sqlResult_t *modifyTime;
/* see if objPath is a dataObj */
memset (myColl, 0, MAX_NAME_LEN);
memset (myData, 0, MAX_NAME_LEN);
if ((status = splitPathByKey (
dataObjInp->objPath, myColl, myData, '/')) < 0) {
return (OBJ_PATH_DOES_NOT_EXIST);
}
memset (&genQueryInp, 0, sizeof (genQueryInp));
snprintf (condStr, MAX_NAME_LEN, "='%s'", myColl);
addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, condStr);
snprintf (condStr, MAX_NAME_LEN, "='%s'", myData);
addInxVal (&genQueryInp.sqlCondInp, COL_DATA_NAME, condStr);
addInxIval (&genQueryInp.selectInp, COL_D_DATA_ID, 1);
addInxIval (&genQueryInp.selectInp, COL_DATA_SIZE, 1);
addInxIval (&genQueryInp.selectInp, COL_DATA_MODE, 1);
addInxIval (&genQueryInp.selectInp, COL_D_REPL_STATUS, 1);
addInxIval (&genQueryInp.selectInp, COL_D_DATA_CHECKSUM, 1);
addInxIval (&genQueryInp.selectInp, COL_D_OWNER_NAME, 1);
addInxIval (&genQueryInp.selectInp, COL_D_OWNER_ZONE, 1);
addInxIval (&genQueryInp.selectInp, COL_D_CREATE_TIME, 1);
addInxIval (&genQueryInp.selectInp, COL_D_MODIFY_TIME, 1);
genQueryInp.maxRows = MAX_SQL_ROWS;
status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
clearGenQueryInp (&genQueryInp);
if (status >= 0) {
if ((dataSize = getSqlResultByInx (genQueryOut, COL_DATA_SIZE))
== NULL) {
rodsLog (LOG_ERROR,
"_rsObjStat: getSqlResultByInx for COL_DATA_SIZE failed");
return (UNMATCHED_KEY_OR_INDEX);
} else if ((dataMode = getSqlResultByInx (genQueryOut,
COL_DATA_MODE)) == NULL) {
rodsLog (LOG_ERROR,
"_rsObjStat: getSqlResultByInx for COL_DATA_MODE failed");
return (UNMATCHED_KEY_OR_INDEX);
} else if ((replStatus = getSqlResultByInx (genQueryOut,
COL_D_REPL_STATUS)) == NULL) {
rodsLog (LOG_ERROR,
"_rsObjStat: getSqlResultByInx for COL_D_REPL_STATUS failed");
return (UNMATCHED_KEY_OR_INDEX);
} else if ((dataId = getSqlResultByInx (genQueryOut,
COL_D_DATA_ID)) == NULL) {
rodsLog (LOG_ERROR,
"_rsObjStat: getSqlResultByInx for COL_D_DATA_ID failed");
return (UNMATCHED_KEY_OR_INDEX);
} else if ((chksum = getSqlResultByInx (genQueryOut,
COL_D_DATA_CHECKSUM)) == NULL) {
rodsLog (LOG_ERROR,
"_rsObjStat:getSqlResultByInx for COL_D_DATA_CHECKSUM failed");
return (UNMATCHED_KEY_OR_INDEX);
} else if ((ownerName = getSqlResultByInx (genQueryOut,
COL_D_OWNER_NAME)) == NULL) {
rodsLog (LOG_ERROR,
"_rsObjStat:getSqlResultByInx for COL_D_OWNER_NAME failed");
return (UNMATCHED_KEY_OR_INDEX);
} else if ((ownerZone = getSqlResultByInx (genQueryOut,
COL_D_OWNER_ZONE)) == NULL) {
rodsLog (LOG_ERROR,
"_rsObjStat:getSqlResultByInx for COL_D_OWNER_ZONE failed");
return (UNMATCHED_KEY_OR_INDEX);
} else if ((createTime = getSqlResultByInx (genQueryOut,
COL_D_CREATE_TIME)) == NULL) {
rodsLog (LOG_ERROR,
"_rsObjStat:getSqlResultByInx for COL_D_CREATE_TIME failed");
return (UNMATCHED_KEY_OR_INDEX);
} else if ((modifyTime = getSqlResultByInx (genQueryOut,
COL_D_MODIFY_TIME)) == NULL) {
rodsLog (LOG_ERROR,
"_rsObjStat:getSqlResultByInx for COL_D_MODIFY_TIME failed");
return (UNMATCHED_KEY_OR_INDEX);
} else {
int i;
*rodsObjStatOut = (rodsObjStat_t *) malloc (sizeof (rodsObjStat_t));
memset (*rodsObjStatOut, 0, sizeof (rodsObjStat_t));
(*rodsObjStatOut)->objType = DATA_OBJ_T; status = (int)DATA_OBJ_T;
/* XXXXXX . dont have numCopies anymore. Replaced by dataMode
* (*rodsObjStatOut)->numCopies = genQueryOut->rowCnt; */
for (i = 0;i < genQueryOut->rowCnt; i++) {
if (atoi (&replStatus->value[replStatus->len * i]) > 0) {
rstrcpy ((*rodsObjStatOut)->dataId,
&dataId->value[dataId->len * i], NAME_LEN);
(*rodsObjStatOut)->objSize =
strtoll (&dataSize->value[dataSize->len * i], 0, 0);
(*rodsObjStatOut)->dataMode =
atoi (&dataMode->value[dataMode->len * i]);
rstrcpy ((*rodsObjStatOut)->chksum,
&chksum->value[chksum->len * i], NAME_LEN);
rstrcpy ((*rodsObjStatOut)->ownerName,
&ownerName->value[ownerName->len * i], NAME_LEN);
rstrcpy ((*rodsObjStatOut)->ownerZone,
&ownerZone->value[ownerZone->len * i], NAME_LEN);
rstrcpy ((*rodsObjStatOut)->createTime,
&createTime->value[createTime->len * i], TIME_LEN);
rstrcpy ((*rodsObjStatOut)->modifyTime,
&modifyTime->value[modifyTime->len * i], TIME_LEN);
break;
}
}
if (strlen ((*rodsObjStatOut)->dataId) == 0) {
/* just use the first one */
rstrcpy ((*rodsObjStatOut)->dataId, dataId->value, NAME_LEN);
(*rodsObjStatOut)->objSize = strtoll (dataSize->value, 0, 0);
rstrcpy ((*rodsObjStatOut)->chksum, chksum->value, NAME_LEN);
rstrcpy ((*rodsObjStatOut)->ownerName, ownerName->value,
NAME_LEN);
rstrcpy ((*rodsObjStatOut)->ownerZone, ownerZone->value,
NAME_LEN);
rstrcpy ((*rodsObjStatOut)->createTime, createTime->value,
NAME_LEN);
rstrcpy ((*rodsObjStatOut)->modifyTime, modifyTime->value,
NAME_LEN);
}
}
freeGenQueryOut (&genQueryOut);
}
return (status);
}
int
rsyncCollToDirUtil (rcComm_t *conn, rodsPath_t *srcPath,
rodsPath_t *targPath, rodsEnv *myRodsEnv, rodsArguments_t *rodsArgs,
dataObjInp_t *dataObjOprInp)
{
int status = 0;
int savedStatus = 0;
char *srcColl, *targDir;
char targChildPath[MAX_NAME_LEN];
#if 0
int collLen;
#else
char parPath[MAX_NAME_LEN], childPath[MAX_NAME_LEN];
#endif
rodsPath_t mySrcPath, myTargPath;
collHandle_t collHandle;
collEnt_t collEnt;
dataObjInp_t childDataObjInp;
if (srcPath == NULL || targPath == NULL) {
rodsLog (LOG_ERROR,
"rsyncCollToDirUtil: NULL srcPath or targPath input");
return (USER__NULL_INPUT_ERR);
}
srcColl = srcPath->outPath;
targDir = targPath->outPath;
if (rodsArgs->recursive != True) {
rodsLog (LOG_ERROR,
"rsyncCollToDirUtil: -r option must be used for collection %s",
targDir);
return (USER_INPUT_OPTION_ERR);
}
#if 0
status = rclOpenCollection (conn, srcColl,
RECUR_QUERY_FG | VERY_LONG_METADATA_FG, &collHandle);
#else
status = rclOpenCollection (conn, srcColl,
VERY_LONG_METADATA_FG, &collHandle);
#endif
if (status < 0) {
rodsLog (LOG_ERROR,
"rsyncCollToDirUtil: rclOpenCollection of %s error. status = %d",
srcColl, status);
return status;
}
memset (&mySrcPath, 0, sizeof (mySrcPath));
memset (&myTargPath, 0, sizeof (myTargPath));
myTargPath.objType = LOCAL_FILE_T;
mySrcPath.objType = DATA_OBJ_T;
#if 0
collLen = strlen (srcColl);
collLen = getOpenedCollLen (&collHandle);
#endif
while ((status = rclReadCollection (conn, &collHandle, &collEnt)) >= 0) {
if (collEnt.objType == DATA_OBJ_T) {
if (rodsArgs->age == True) {
if (ageExceeded (rodsArgs->agevalue,
atoi (collEnt.modifyTime), rodsArgs->verbose,
collEnt.dataName, collEnt.dataSize)) continue;
}
#if 0
snprintf (myTargPath.outPath, MAX_NAME_LEN, "%s%s/%s",
targDir, collEnt.collName + collLen,
collEnt.dataName);
#else
snprintf (myTargPath.outPath, MAX_NAME_LEN, "%s/%s",
targDir, collEnt.dataName);
#endif
snprintf (mySrcPath.outPath, MAX_NAME_LEN, "%s/%s",
collEnt.collName, collEnt.dataName);
/* fill in some info for mySrcPath */
if (strlen (mySrcPath.dataId) == 0)
rstrcpy (mySrcPath.dataId, collEnt.dataId, NAME_LEN);
mySrcPath.size = collEnt.dataSize;
mySrcPath.objMode = collEnt.dataMode;
rstrcpy (mySrcPath.chksum, collEnt.chksum, CHKSUM_LEN);
mySrcPath.objState = EXIST_ST;
getFileType (&myTargPath);
status = rsyncDataToFileUtil (conn, &mySrcPath, &myTargPath,
myRodsEnv, rodsArgs, dataObjOprInp);
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"rsyncCollUtil: rsyncDataObjUtil failed for %s. status = %d",
mySrcPath.outPath, status);
/* need to set global error here */
savedStatus = status;
status = 0;
}
} else if (collEnt.objType == COLL_OBJ_T) {
#if 0
snprintf (targChildPath, MAX_NAME_LEN, "%s/%s",
targDir, collEnt.collName + collLen);
#else
if ((status = splitPathByKey (
collEnt.collName, parPath, childPath, '/')) < 0) {
rodsLogError (LOG_ERROR, status,
"rsyncCollToDirUtil:: splitPathByKey for %s error, stat=%d",
collEnt.collName, status);
return (status);
}
snprintf (targChildPath, MAX_NAME_LEN, "%s/%s",
targDir, childPath);
#endif
/* only do the sync if no -l option specified */
if ( rodsArgs->longOption != True ) {
mkdirR (targDir, targChildPath, 0750);
}
#if 0
if (collEnt.specColl.collClass != NO_SPEC_COLL) {
#endif
/* the child is a spec coll. need to drill down */
childDataObjInp = *dataObjOprInp;
if (collEnt.specColl.collClass != NO_SPEC_COLL)
childDataObjInp.specColl = &collEnt.specColl;
else
childDataObjInp.specColl = NULL;
rstrcpy (myTargPath.outPath, targChildPath, MAX_NAME_LEN);
rstrcpy (mySrcPath.outPath, collEnt.collName, MAX_NAME_LEN);
status = rsyncCollToDirUtil (conn, &mySrcPath,
&myTargPath, myRodsEnv, rodsArgs, &childDataObjInp);
if (status < 0 && status != CAT_NO_ROWS_FOUND) {
return (status);
}
#if 0
}
#endif
}
}
rclCloseCollection (&collHandle);
if (savedStatus < 0) {
return (savedStatus);
} else if (status == CAT_NO_ROWS_FOUND ||
status == SYS_SPEC_COLL_OBJ_NOT_EXIST) {
return (0);
} else {
return (status);
}
}
int
rsyncDirToCollUtil (rcComm_t *conn, rodsPath_t *srcPath,
rodsPath_t *targPath, rodsEnv *myRodsEnv, rodsArguments_t *rodsArgs,
dataObjInp_t *dataObjOprInp)
{
int status = 0;
int savedStatus = 0;
#ifndef USE_BOOST_FS
DIR *dirPtr;
struct dirent *myDirent;
#ifndef windows_platform
struct stat statbuf;
#else
struct irodsntstat statbuf;
#endif
#endif /* #ifndef USE_BOOST_FS */
char *srcDir, *targColl;
rodsPath_t mySrcPath, myTargPath;
if (srcPath == NULL || targPath == NULL) {
rodsLog (LOG_ERROR,
"rsyncDirToCollUtil: NULL srcPath or targPath input");
return (USER__NULL_INPUT_ERR);
}
srcDir = srcPath->outPath;
targColl = targPath->outPath;
if (isPathSymlink (rodsArgs, srcDir) > 0) return 0;
if (rodsArgs->recursive != True) {
rodsLog (LOG_ERROR,
"rsyncDirToCollUtil: -r option must be used for putting %s directory",
srcDir);
return (USER_INPUT_OPTION_ERR);
}
#ifdef USE_BOOST_FS
path srcDirPath (srcDir);
if (!exists(srcDirPath) || !is_directory(srcDirPath)) {
#else
dirPtr = opendir (srcDir);
if (dirPtr == NULL) {
#endif /* USE_BOOST_FS */
rodsLog (LOG_ERROR,
"rsyncDirToCollUtil: opendir local dir error for %s, errno = %d\n",
srcDir, errno);
return (USER_INPUT_PATH_ERR);
}
if (rodsArgs->verbose == True) {
fprintf (stdout, "C- %s:\n", targColl);
}
memset (&mySrcPath, 0, sizeof (mySrcPath));
memset (&myTargPath, 0, sizeof (myTargPath));
myTargPath.objType = DATA_OBJ_T;
mySrcPath.objType = LOCAL_FILE_T;
#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 (mySrcPath.outPath, 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 (mySrcPath.outPath, MAX_NAME_LEN, "%s/%s",
srcDir, myDirent->d_name);
#endif /* USE_BOOST_FS */
if (isPathSymlink (rodsArgs, mySrcPath.outPath) > 0) continue;
#ifdef USE_BOOST_FS
#if 0
path p (mySrcPath.outPath);
#endif
if (!exists(p)) {
#else
#ifndef windows_platform
status = stat (mySrcPath.outPath, &statbuf);
#else
status = iRODSNt_stat(mySrcPath.outPath, &statbuf);
#endif
if (status != 0) {
closedir (dirPtr);
#endif /* USE_BOOST_FS */
rodsLog (LOG_ERROR,
"rsyncDirToCollUtil: stat error for %s, errno = %d\n",
mySrcPath.outPath, errno);
return (USER_INPUT_PATH_ERR);
}
#ifndef USE_BOOST_FS
if ((statbuf.st_mode & S_IFREG) != 0 && rodsArgs->age == True) {
if (ageExceeded (rodsArgs->agevalue, statbuf.st_mtime,
rodsArgs->verbose, mySrcPath.outPath, statbuf.st_size))
continue;
}
#endif /* #ifndef USE_BOOST_FS */
#ifdef FILESYSTEM_META
getFileMetaFromPath(mySrcPath.outPath, &dataObjOprInp->condInput);
#endif
bzero (&myTargPath, sizeof (myTargPath));
#ifdef USE_BOOST_FS
path childPath = p.filename();
snprintf (myTargPath.outPath, MAX_NAME_LEN, "%s/%s",
targColl, childPath.c_str());
if (is_symlink (p)) {
path cp = read_symlink (p);
snprintf (mySrcPath.outPath, MAX_NAME_LEN, "%s/%s",
srcDir, cp.c_str ());
p = path (mySrcPath.outPath);
}
dataObjOprInp->createMode = getPathStMode (p);
if (is_regular_file(p)) {
#else
snprintf (myTargPath.outPath, MAX_NAME_LEN, "%s/%s",
targColl, myDirent->d_name);
dataObjOprInp->createMode = statbuf.st_mode;
if ((statbuf.st_mode & S_IFREG) != 0) { /* a file */
#endif
myTargPath.objType = DATA_OBJ_T;
mySrcPath.objType = LOCAL_FILE_T;
mySrcPath.objState = EXIST_ST;
#ifdef USE_BOOST_FS
mySrcPath.size = file_size (p);
#else
mySrcPath.size = statbuf.st_size;
#endif
getRodsObjType (conn, &myTargPath);
status = rsyncFileToDataUtil (conn, &mySrcPath, &myTargPath,
myRodsEnv, rodsArgs, dataObjOprInp);
/* fix a big mem leak */
if (myTargPath.rodsObjStat != NULL) {
freeRodsObjStat (myTargPath.rodsObjStat);
myTargPath.rodsObjStat = NULL;
}
#if 0
if (myTargPath.objState != NOT_EXIST_ST)
freeRodsObjStat (myTargPath.rodsObjStat);
#endif
#ifdef USE_BOOST_FS
} else if (is_directory(p)) {
#else
} else if ((statbuf.st_mode & S_IFDIR) != 0) { /* a directory */
#endif
status = 0;
/* only do the sync if no -l option specified */
if ( rodsArgs->longOption != True ) {
#ifdef FILESYSTEM_META
status = mkCollRWithDirMeta (conn, targColl,
myTargPath.outPath, mySrcPath.outPath);
#else
status = mkCollR (conn, targColl, myTargPath.outPath);
#endif
}
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"rsyncDirToCollUtil: mkCollR error for %s",
myTargPath.outPath);
} else {
myTargPath.objType = COLL_OBJ_T;
mySrcPath.objType = LOCAL_DIR_T;
mySrcPath.objState = myTargPath.objState = EXIST_ST;
getRodsObjType (conn, &myTargPath);
status = rsyncDirToCollUtil (conn, &mySrcPath, &myTargPath,
myRodsEnv, rodsArgs, dataObjOprInp);
/* fix a big mem leak */
if (myTargPath.rodsObjStat != NULL) {
freeRodsObjStat (myTargPath.rodsObjStat);
myTargPath.rodsObjStat = NULL;
}
#if 0
if (myTargPath.objState != NOT_EXIST_ST)
freeRodsObjStat (myTargPath.rodsObjStat);
#endif
}
} else {
rodsLog (LOG_ERROR,
#ifdef USE_BOOST_FS
"rsyncDirToCollUtil: unknown local path %s",
mySrcPath.outPath);
#else
"rsyncDirToCollUtil: unknown local path type %d for %s",
statbuf.st_mode, mySrcPath.outPath);
#endif /* USE_BOOST_FS */
status = USER_INPUT_PATH_ERR;
}
if (status < 0) {
savedStatus = status;
rodsLogError (LOG_ERROR, status,
"rsyncDirToCollUtil: put %s failed. status = %d",
mySrcPath.outPath, status);
}
}
#ifndef USE_BOOST_FS
closedir (dirPtr);
#endif
if (savedStatus < 0) {
return (savedStatus);
} else if (status == CAT_NO_ROWS_FOUND ||
status == SYS_SPEC_COLL_OBJ_NOT_EXIST) {
return (0);
} else {
return (status);
}
}
int
rsyncCollToCollUtil (rcComm_t *conn, rodsPath_t *srcPath,
rodsPath_t *targPath, rodsEnv *myRodsEnv, rodsArguments_t *rodsArgs,
dataObjCopyInp_t *dataObjCopyInp)
{
int status = 0;
int savedStatus = 0;
char *srcColl, *targColl;
char targChildPath[MAX_NAME_LEN];
#if 0
int collLen;
#else
char parPath[MAX_NAME_LEN], childPath[MAX_NAME_LEN];
#endif
rodsPath_t mySrcPath, myTargPath;
collHandle_t collHandle;
collEnt_t collEnt;
dataObjCopyInp_t childDataObjCopyInp;
dataObjInp_t *dataObjOprInp = &collHandle.dataObjInp;
if (srcPath == NULL || targPath == NULL) {
rodsLog (LOG_ERROR,
"rsyncCollToCollUtil: NULL srcPath or targPath input");
return (USER__NULL_INPUT_ERR);
}
srcColl = srcPath->outPath;
targColl = targPath->outPath;
if (rodsArgs->recursive != True) {
rodsLog (LOG_ERROR,
"rsyncCollToCollUtil: -r option must be used for collection %s",
targColl);
return (USER_INPUT_OPTION_ERR);
}
#if 0
status = rclOpenCollection (conn, srcColl,
RECUR_QUERY_FG | VERY_LONG_METADATA_FG, &collHandle);
#else
status = rclOpenCollection (conn, srcColl,
VERY_LONG_METADATA_FG, &collHandle);
#endif
if (status < 0) {
rodsLog (LOG_ERROR,
"getCollUtil: rclOpenCollection of %s error. status = %d",
srcColl, status);
return status;
}
if (dataObjOprInp->specColl != NULL) {
if (rodsArgs->verbose == True) {
if (rodsArgs->verbose == True) {
char objType[NAME_LEN];
status = getSpecCollTypeStr (dataObjOprInp->specColl, objType);
if (status < 0)
fprintf (stdout, "C- %s :\n", targColl);
else
fprintf (stdout, "C- %s %-5.5s :\n", targColl, objType);
}
}
}
memset (&mySrcPath, 0, sizeof (mySrcPath));
memset (&myTargPath, 0, sizeof (myTargPath));
myTargPath.objType = DATA_OBJ_T;
mySrcPath.objType = DATA_OBJ_T;
#if 0
collLen = strlen (srcColl);
collLen = getOpenedCollLen (&collHandle);
#endif
while ((status = rclReadCollection (conn, &collHandle, &collEnt)) >= 0) {
if (collEnt.objType == DATA_OBJ_T) {
if (rodsArgs->age == True) {
if (ageExceeded (rodsArgs->agevalue,
atoi (collEnt.modifyTime), rodsArgs->verbose,
collEnt.dataName, collEnt.dataSize)) continue;
}
#if 0
snprintf (myTargPath.outPath, MAX_NAME_LEN, "%s%s/%s",
targColl, collEnt.collName + collLen,
collEnt.dataName);
#else
snprintf (myTargPath.outPath, MAX_NAME_LEN, "%s/%s",
targColl, collEnt.dataName);
#endif
snprintf (mySrcPath.outPath, MAX_NAME_LEN, "%s/%s",
collEnt.collName, collEnt.dataName);
/* fill in some info for mySrcPath */
if (strlen (mySrcPath.dataId) == 0)
rstrcpy (mySrcPath.dataId, collEnt.dataId, NAME_LEN);
mySrcPath.size = collEnt.dataSize;
rstrcpy (mySrcPath.chksum, collEnt.chksum, CHKSUM_LEN);
mySrcPath.objState = EXIST_ST;
#if 0
getFileType (&myTargPath);
#else
getRodsObjType (conn, &myTargPath);
#endif
status = rsyncDataToDataUtil (conn, &mySrcPath,
&myTargPath, myRodsEnv, rodsArgs, dataObjCopyInp);
if (myTargPath.rodsObjStat != NULL) {
freeRodsObjStat (myTargPath.rodsObjStat);
myTargPath.rodsObjStat = NULL;
}
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"rsyncCollToCollUtil: rsyncDataToDataUtil failed for %s.stat=%d",
myTargPath.outPath, status);
/* need to set global error here */
savedStatus = status;
status = 0;
}
} else if (collEnt.objType == COLL_OBJ_T) {
#if 0
if (strlen (collEnt.collName) <= collLen)
continue;
snprintf (targChildPath, MAX_NAME_LEN, "%s%s",
targColl, collEnt.collName + collLen);
#else
if ((status = splitPathByKey (
collEnt.collName, parPath, childPath, '/')) < 0) {
rodsLogError (LOG_ERROR, status,
"rsyncCollToCollUtil:: splitPathByKey for %s error, status = %d",
collEnt.collName, status);
return (status);
}
snprintf (targChildPath, MAX_NAME_LEN, "%s/%s",
targColl, childPath);
#endif
if ( rodsArgs->longOption != True ) { /* only do the sync if no -l option specified */
#ifdef FILESYSTEM_META
mkCollWithSrcCollMeta (conn, targChildPath, collEnt.collName);
#else
mkColl (conn, targChildPath);
#endif
}
#if 0
if (collEnt.specColl.collClass != NO_SPEC_COLL) {
#endif
/* the child is a spec coll. need to drill down */
childDataObjCopyInp = *dataObjCopyInp;
if (collEnt.specColl.collClass != NO_SPEC_COLL)
childDataObjCopyInp.srcDataObjInp.specColl =
&collEnt.specColl;
rstrcpy (myTargPath.outPath, targChildPath, MAX_NAME_LEN);
rstrcpy (mySrcPath.outPath, collEnt.collName, MAX_NAME_LEN);
status = rsyncCollToCollUtil (conn, &mySrcPath,
&myTargPath, myRodsEnv, rodsArgs, &childDataObjCopyInp);
if (status < 0 && status != CAT_NO_ROWS_FOUND) {
return (status);
}
#if 0
}
#endif
}
}
rclCloseCollection (&collHandle);
if (savedStatus < 0) {
return (savedStatus);
} else if (status == CAT_NO_ROWS_FOUND ||
status == SYS_SPEC_COLL_OBJ_NOT_EXIST) {
return (0);
} else {
return (status);
}
}
int
initCondForRsync (rodsEnv *myRodsEnv, rodsArguments_t *rodsArgs,
dataObjInp_t *dataObjInp)
{
char *myResc = NULL;
char tmpStr[NAME_LEN];
if (dataObjInp == NULL) {
rodsLog (LOG_ERROR,
"initCondForRsync: NULL dataObjOprInp input");
return (USER__NULL_INPUT_ERR);
}
memset (dataObjInp, 0, sizeof (dataObjInp_t));
if (rodsArgs == NULL) {
return (0);
}
/* always turn on the force flag */
addKeyVal (&dataObjInp->condInput, FORCE_FLAG_KW, "");
if (rodsArgs->sizeFlag == True) {
addKeyVal (&dataObjInp->condInput, VERIFY_BY_SIZE_KW, "");
}
if (rodsArgs->all == True) {
addKeyVal (&dataObjInp->condInput, ALL_KW, "");
}
#ifdef windows_platform
dataObjInp->numThreads = NO_THREADING;
#else
if (rodsArgs->number == True) {
if (rodsArgs->numberValue == 0) {
dataObjInp->numThreads = NO_THREADING;
} else {
dataObjInp->numThreads = rodsArgs->numberValue;
}
}
#endif
if (rodsArgs->resource == True) {
if (rodsArgs->resourceString == NULL) {
rodsLog (LOG_ERROR,
"initCondForRepl: NULL resourceString error");
return (USER__NULL_INPUT_ERR);
} else {
myResc = rodsArgs->resourceString;
addKeyVal (&dataObjInp->condInput, DEST_RESC_NAME_KW,
rodsArgs->resourceString);
}
} else if (myRodsEnv != NULL && strlen (myRodsEnv->rodsDefResource) > 0) {
myResc = myRodsEnv->rodsDefResource;
addKeyVal (&dataObjInp->condInput, DEST_RESC_NAME_KW,
myRodsEnv->rodsDefResource);
}
if (rodsArgs->age == True) {
snprintf (tmpStr, NAME_LEN, "%d", rodsArgs->agevalue);
addKeyVal (&dataObjInp->condInput, AGE_KW, tmpStr);
}
return (0);
}
int // JMC - backport 4680
getPhyPath(
rsComm_t* _comm,
char* _obj_name,
char* _resource,
char* _phy_path,
char* _resc_hier ) {
// =-=-=-=-=-=-=-
// if no resc hier is specified, call resolve on the object to
// ask the resource composition to pick a valid hier for open
std::string resc_hier;
if ( 0 == strlen( _resc_hier ) ) {
dataObjInp_t data_inp;
memset( &data_inp, 0, sizeof( data_inp ) );
strncpy( data_inp.objPath, _obj_name, MAX_NAME_LEN );
irods::error ret = irods::resolve_resource_hierarchy(
irods::OPEN_OPERATION,
_comm,
&data_inp,
resc_hier );
if ( !ret.ok() ) {
irods::log( PASS( ret ) );
return SYS_INVALID_INPUT_PARAM;
}
}
else {
resc_hier = _resc_hier;
}
std::string root_resc;
irods::hierarchy_parser parser;
parser.set_string( resc_hier );
parser.first_resc( root_resc );
// =-=-=-=-=-=-=-
// perform a genquery to get the physical path of the data object
// as the hier reolve does not do that for us
genQueryOut_t* gen_out = NULL;
char tmp_str [ MAX_NAME_LEN ];
char logical_end_name [ MAX_NAME_LEN ];
char logical_parent_dir_name[ MAX_NAME_LEN ];
// =-=-=-=-=-=-=-
// split the object path by the last delimiter /
int status = splitPathByKey(
_obj_name,
logical_parent_dir_name, MAX_NAME_LEN,
logical_end_name, MAX_NAME_LEN, '/' );
genQueryInp_t gen_inp;
memset( &gen_inp, 0, sizeof( genQueryInp_t ) );
// =-=-=-=-=-=-=-
// add query to the struct for the data object name
snprintf( tmp_str, MAX_NAME_LEN, "='%s'", logical_end_name );
addInxVal( &gen_inp.sqlCondInp, COL_DATA_NAME, tmp_str );
// =-=-=-=-=-=-=-
// add query to the struct for the collection name
snprintf( tmp_str, MAX_NAME_LEN, "='%s'", logical_parent_dir_name );
addInxVal( &gen_inp.sqlCondInp, COL_COLL_NAME, tmp_str );
// =-=-=-=-=-=-=-
// add query to the struct for the resource hierarchy
snprintf( tmp_str, MAX_NAME_LEN, "='%s'", resc_hier.c_str() );
addInxVal( &gen_inp.sqlCondInp, COL_D_RESC_HIER, tmp_str );
// =-=-=-=-=-=-=-
// include request for data path and resource hierarchy
addInxIval( &gen_inp.selectInp, COL_D_DATA_PATH, 1 );
// =-=-=-=-=-=-=-
// request only 2 results in the set
gen_inp.maxRows = 2;
status = rsGenQuery( _comm, &gen_inp, &gen_out );
if ( status >= 0 ) {
// =-=-=-=-=-=-=-
// extract the physical path from the query
sqlResult_t* phy_path_res = getSqlResultByInx( gen_out, COL_D_DATA_PATH );
if ( !phy_path_res ) {
rodsLog( LOG_ERROR,
"getPhyPath: getSqlResultByInx for COL_D_DATA_PATH failed" );
return UNMATCHED_KEY_OR_INDEX;
}
// =-=-=-=-=-=-=-
// copy the results to the out variables
strncpy( _phy_path, phy_path_res->value, MAX_NAME_LEN );
strncpy( _resource, root_resc.c_str(), root_resc.size() );
strncpy( _resc_hier, resc_hier.c_str(), resc_hier.size() );
freeGenQueryOut( &gen_out );
}
clearGenQueryInp( &gen_inp );
return status;
}
int
rsMkTrashPath( rsComm_t *rsComm, char *objPath, char *trashPath ) {
int status;
char *tmpStr;
char startTrashPath[MAX_NAME_LEN];
char destTrashColl[MAX_NAME_LEN], myFile[MAX_NAME_LEN];
char *trashPathPtr;
trashPathPtr = trashPath;
*trashPathPtr = '/';
trashPathPtr++;
tmpStr = objPath + 1;
/* copy the zone */
while ( *tmpStr != '\0' ) {
*trashPathPtr = *tmpStr;
trashPathPtr ++;
if ( *tmpStr == '/' ) {
tmpStr ++;
break;
}
tmpStr ++;
}
if ( *tmpStr == '\0' ) {
rodsLog( LOG_ERROR,
"rsMkTrashPath: input path %s too short", objPath );
return USER_INPUT_PATH_ERR;
}
/* skip "home/userName/" or "home/userName#" */
if ( strncmp( tmpStr, "home/", 5 ) == 0 ) {
int nameLen;
tmpStr += 5;
nameLen = strlen( rsComm->clientUser.userName );
if ( strncmp( tmpStr, rsComm->clientUser.userName, nameLen ) == 0 &&
( *( tmpStr + nameLen ) == '/' || *( tmpStr + nameLen ) == '#' ) ) {
/* tmpStr += (nameLen + 1); */
tmpStr = strchr( tmpStr, '/' ) + 1;
}
}
/* don't want to go back beyond /myZone/trash/home */
*trashPathPtr = '\0';
snprintf( startTrashPath, MAX_NAME_LEN, "%strash/home", trashPath );
/* add home/userName/ */
if ( rsComm->clientUser.authInfo.authFlag == REMOTE_USER_AUTH ||
rsComm->clientUser.authInfo.authFlag == REMOTE_PRIV_USER_AUTH ) {
/* remote user */
snprintf( trashPathPtr, MAX_NAME_LEN, "trash/home/%s#%s/%s",
rsComm->clientUser.userName, rsComm->clientUser.rodsZone, tmpStr );
}
else {
snprintf( trashPathPtr, MAX_NAME_LEN, "trash/home/%s/%s",
rsComm->clientUser.userName, tmpStr );
}
if ( ( status = splitPathByKey( trashPath, destTrashColl, MAX_NAME_LEN, myFile, MAX_NAME_LEN, '/' ) ) < 0 ) {
rodsLog( LOG_ERROR,
"rsMkTrashPath: splitPathByKey error for %s ", trashPath );
return USER_INPUT_PATH_ERR;
}
status = rsMkCollR( rsComm, startTrashPath, destTrashColl );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"rsMkTrashPath: rsMkCollR error for startPath %s, destPath %s ",
startTrashPath, destTrashColl );
}
return status;
}
int
dirPathReg (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp, char *filePath,
rescInfo_t *rescInfo)
{
collInp_t collCreateInp;
fileOpendirInp_t fileOpendirInp;
fileClosedirInp_t fileClosedirInp;
int rescTypeInx;
int status;
int dirFd;
dataObjInp_t subPhyPathRegInp;
fileReaddirInp_t fileReaddirInp;
rodsDirent_t *rodsDirent = NULL;
rodsObjStat_t *rodsObjStatOut = NULL;
int forceFlag;
fileStatInp_t fileStatInp;
rodsStat_t *myStat = NULL;
char curcoll[MAX_NAME_LEN];
*curcoll = '\0';
rescTypeInx = rescInfo->rescTypeInx;
status = collStat (rsComm, phyPathRegInp, &rodsObjStatOut);
if (status < 0) {
memset (&collCreateInp, 0, sizeof (collCreateInp));
rstrcpy (collCreateInp.collName, phyPathRegInp->objPath,
MAX_NAME_LEN);
/* no need to resolve sym link */
addKeyVal (&collCreateInp.condInput, TRANSLATED_PATH_KW, "");
#ifdef FILESYSTEM_META
/* stat the source directory to track the */
/* original directory meta-data */
memset (&fileStatInp, 0, sizeof (fileStatInp));
rstrcpy (fileStatInp.fileName, filePath, MAX_NAME_LEN);
fileStatInp.fileType = (fileDriverType_t)RescTypeDef[rescTypeInx].driverType;
rstrcpy (fileStatInp.addr.hostAddr, rescInfo->rescLoc, NAME_LEN);
status = rsFileStat (rsComm, &fileStatInp, &myStat);
if (status != 0) {
rodsLog (LOG_ERROR,
"dirPathReg: rsFileStat failed for %s, status = %d",
filePath, status);
return (status);
}
getFileMetaFromStat (myStat, &collCreateInp.condInput);
addKeyVal(&collCreateInp.condInput, FILE_SOURCE_PATH_KW, filePath);
free (myStat);
#endif /* FILESYSTEM_META */
/* create the coll just in case it does not exist */
status = rsCollCreate (rsComm, &collCreateInp);
clearKeyVal (&collCreateInp.condInput);
if (status < 0) {
rodsLog (LOG_ERROR,
"dirPathReg: rsCollCreate %s error. status = %d",
phyPathRegInp->objPath, status);
return status;
}
} else if (rodsObjStatOut->specColl != NULL) {
freeRodsObjStat (rodsObjStatOut);
rodsLog (LOG_ERROR,
"dirPathReg: %s already mounted", phyPathRegInp->objPath);
return (SYS_MOUNT_MOUNTED_COLL_ERR);
}
freeRodsObjStat (rodsObjStatOut);
memset (&fileOpendirInp, 0, sizeof (fileOpendirInp));
rstrcpy (fileOpendirInp.dirName, filePath, MAX_NAME_LEN);
fileOpendirInp.fileType = (fileDriverType_t)RescTypeDef[rescTypeInx].driverType;
rstrcpy (fileOpendirInp.addr.hostAddr, rescInfo->rescLoc, NAME_LEN);
dirFd = rsFileOpendir (rsComm, &fileOpendirInp);
if (dirFd < 0) {
rodsLog (LOG_ERROR,
"dirPathReg: rsFileOpendir for %s error, status = %d",
filePath, dirFd);
return (dirFd);
}
fileReaddirInp.fileInx = dirFd;
if (getValByKey (&phyPathRegInp->condInput, FORCE_FLAG_KW) != NULL) {
forceFlag = 1;
} else {
forceFlag = 0;
}
while ((status = rsFileReaddir (rsComm, &fileReaddirInp, &rodsDirent))
>= 0) {
int len;
if (strlen (rodsDirent->d_name) == 0) break;
if (strcmp (rodsDirent->d_name, ".") == 0 ||
strcmp (rodsDirent->d_name, "..") == 0) {
free (rodsDirent);
continue;
}
if (matchPathname(ExcludePatterns, rodsDirent->d_name, filePath)) {
continue;
}
memset (&fileStatInp, 0, sizeof (fileStatInp));
if (RescTypeDef[rescTypeInx].incParentDir == NO_INC_PARENT_DIR) {
/* don't include parent path */
snprintf (fileStatInp.fileName, MAX_NAME_LEN, "%s",
rodsDirent->d_name);
} else if (RescTypeDef[rescTypeInx].incParentDir ==
PHYPATH_IN_DIR_PTR) {
/* we can do this locally because this API is executed at the
* resource server */
getPhyPathInOpenedDir (dirFd, rodsDirent->d_ino,
fileStatInp.fileName);
} else {
len = strlen (filePath);
if (filePath[len - 1] == '/') {
/* already has a '/' */
snprintf (fileStatInp.fileName, MAX_NAME_LEN, "%s%s",
filePath, rodsDirent->d_name);
} else {
snprintf (fileStatInp.fileName, MAX_NAME_LEN, "%s/%s",
filePath, rodsDirent->d_name);
}
}
fileStatInp.fileType = fileOpendirInp.fileType;
fileStatInp.addr = fileOpendirInp.addr;
myStat = NULL;
status = rsFileStat (rsComm, &fileStatInp, &myStat);
if (status != 0) {
rodsLog (LOG_ERROR,
"dirPathReg: rsFileStat failed for %s, status = %d",
fileStatInp.fileName, status);
free (rodsDirent);
return (status);
}
if (RescTypeDef[rescTypeInx].driverType == TDS_FILE_TYPE &&
strchr (rodsDirent->d_name, '/') != NULL) {
/* TDS may contain '/' in the file path */
char *tmpPtr = rodsDirent->d_name;
/* replace '/' with '.' */
while (*tmpPtr != '\0') {
if (*tmpPtr == '/') *tmpPtr = '.';
tmpPtr ++;
}
}
if (RescTypeDef[rescTypeInx].incParentDir == PHYPATH_IN_DIR_PTR) {
/* the st_mode is stored in the opened dir */
myStat->st_mode = getStModeInOpenedDir (dirFd, rodsDirent->d_ino);
freePhyPathInOpenedDir (dirFd, rodsDirent->d_ino);
}
subPhyPathRegInp = *phyPathRegInp;
if (RescTypeDef[rescTypeInx].incParentDir == NO_INC_PARENT_DIR) {
char myDir[MAX_NAME_LEN], myFile[MAX_NAME_LEN];
/* d_name is a full path, need to split it */
if ((status = splitPathByKey (rodsDirent->d_name, myDir, myFile,
'/')) < 0) {
rodsLog (LOG_ERROR,
"dirPathReg: splitPathByKey error for %s ",
rodsDirent->d_name);
continue;
}
snprintf (subPhyPathRegInp.objPath, MAX_NAME_LEN, "%s/%s",
phyPathRegInp->objPath, myFile);
} else if (RescTypeDef[rescTypeInx].incParentDir ==
PHYPATH_IN_DIR_PTR) {
char curdir[MAX_NAME_LEN];
*curdir = '\0';
getCurDirInOpenedDir (dirFd, curdir);
if (strlen (curdir) > 0) {
/* see if we have done it already */
int len = strlen (subPhyPathRegInp.objPath);
if (*curcoll == '\0' ||
strcmp (&curcoll[len + 1], curdir) != 0) {
snprintf (curcoll, MAX_NAME_LEN, "%s/%s",
phyPathRegInp->objPath, curdir);
rsMkCollR (rsComm, phyPathRegInp->objPath, curcoll);
}
snprintf (subPhyPathRegInp.objPath, MAX_NAME_LEN, "%s/%s",
curcoll, rodsDirent->d_name);
} else {
snprintf (subPhyPathRegInp.objPath, MAX_NAME_LEN, "%s/%s",
phyPathRegInp->objPath, rodsDirent->d_name);
}
} else {
snprintf (subPhyPathRegInp.objPath, MAX_NAME_LEN, "%s/%s",
phyPathRegInp->objPath, rodsDirent->d_name);
}
if ((myStat->st_mode & S_IFREG) != 0) { /* a file */
if (forceFlag > 0) {
/* check if it already exists */
if (isData (rsComm, subPhyPathRegInp.objPath, NULL) >= 0) {
free (myStat);
free (rodsDirent);
continue;
}
}
subPhyPathRegInp.dataSize = myStat->st_size;
if (getValByKey (&phyPathRegInp->condInput, REG_REPL_KW) != NULL) {
status = filePathRegRepl (rsComm, &subPhyPathRegInp,
fileStatInp.fileName, rescInfo);
} else {
addKeyVal (&subPhyPathRegInp.condInput, FILE_PATH_KW,
fileStatInp.fileName);
status = filePathReg (rsComm, &subPhyPathRegInp,
fileStatInp.fileName, rescInfo);
}
} else if ((myStat->st_mode & S_IFDIR) != 0) { /* a directory */
len = strlen (subPhyPathRegInp.objPath);
if (subPhyPathRegInp.objPath[len - 1] == '/') {
/* take out the end '/' for objPath */
subPhyPathRegInp.objPath[len - 1] = '\0';
}
status = dirPathReg (rsComm, &subPhyPathRegInp,
fileStatInp.fileName, rescInfo);
}
if (status < 0) return status;
free (myStat);
free (rodsDirent);
}
if (status == -1) { /* just EOF */
status = 0;
}
fileClosedirInp.fileInx = dirFd;
rsFileClosedir (rsComm, &fileClosedirInp);
return (status);
}
int
getCollUtil (rcComm_t **myConn, char *srcColl, char *targDir,
rodsEnv *myRodsEnv, rodsArguments_t *rodsArgs, dataObjInp_t *dataObjOprInp,
rodsRestart_t *rodsRestart)
{
int status = 0;
int savedStatus = 0;
char srcChildPath[MAX_NAME_LEN], targChildPath[MAX_NAME_LEN];
#if 0
int collLen;
#else
char parPath[MAX_NAME_LEN], childPath[MAX_NAME_LEN];
#endif
collHandle_t collHandle;
collEnt_t collEnt;
dataObjInp_t childDataObjInp;
rcComm_t *conn;
if (srcColl == NULL || targDir == NULL) {
rodsLog (LOG_ERROR,
"getCollUtil: NULL srcColl or targDir input");
return (USER__NULL_INPUT_ERR);
}
if (rodsArgs->recursive != True) {
rodsLog (LOG_ERROR,
"getCollUtil: -r option must be used for getting %s collection",
targDir);
return (USER_INPUT_OPTION_ERR);
}
if (rodsArgs->redirectConn == True) {
int reconnFlag;
if (rodsArgs->reconnect == True) {
reconnFlag = RECONN_TIMEOUT;
} else {
reconnFlag = NO_RECONN;
}
/* reconnect to the resource server */
rstrcpy (dataObjOprInp->objPath, srcColl, MAX_NAME_LEN);
redirectConnToRescSvr (myConn, dataObjOprInp, myRodsEnv, reconnFlag);
rodsArgs->redirectConn = 0; /* only do it once */
}
conn = *myConn;
printCollOrDir (targDir, LOCAL_DIR_T, rodsArgs, dataObjOprInp->specColl);
#if 0
status = rclOpenCollection (conn, srcColl, RECUR_QUERY_FG,
&collHandle);
#else
status = rclOpenCollection (conn, srcColl, 0, &collHandle);
#endif
if (status < 0) {
rodsLog (LOG_ERROR,
"getCollUtil: rclOpenCollection of %s error. status = %d",
srcColl, status);
return status;
}
#if 0
collLen = strlen (srcColl);
collLen = getOpenedCollLen (&collHandle);
#endif
while ((status = rclReadCollection (conn, &collHandle, &collEnt)) >= 0) {
if (collEnt.objType == DATA_OBJ_T) {
rodsLong_t mySize;
mySize = collEnt.dataSize; /* have to save it. May be freed */
#if 0
snprintf (targChildPath, MAX_NAME_LEN, "%s%s/%s",
targDir, collEnt.collName + collLen,
collEnt.dataName);
#else
snprintf (targChildPath, MAX_NAME_LEN, "%s/%s",
targDir, collEnt.dataName);
#endif
snprintf (srcChildPath, MAX_NAME_LEN, "%s/%s",
collEnt.collName, collEnt.dataName);
status = chkStateForResume (conn, rodsRestart, targChildPath,
rodsArgs, LOCAL_FILE_T, &dataObjOprInp->condInput, 1);
if (status < 0) {
/* restart failed */
break;
} else if (status == 0) {
continue;
}
status = getDataObjUtil (conn, srcChildPath,
targChildPath, mySize, collEnt.dataMode, myRodsEnv, rodsArgs,
dataObjOprInp);
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"getCollUtil: getDataObjUtil failed for %s. status = %d",
srcChildPath, status);
savedStatus = status;
if (rodsRestart->fd > 0) break;
} else {
status = procAndWrriteRestartFile (rodsRestart, targChildPath);
}
} else if (collEnt.objType == COLL_OBJ_T) {
if ((status = splitPathByKey (
collEnt.collName, parPath, childPath, '/')) < 0) {
rodsLogError (LOG_ERROR, status,
"getCollUtil:: splitPathByKey for %s error, status = %d",
collEnt.collName, status);
return (status);
}
snprintf (targChildPath, MAX_NAME_LEN, "%s/%s",
targDir, childPath);
mkdirR (targDir, targChildPath, 0750);
/* the child is a spec coll. need to drill down */
childDataObjInp = *dataObjOprInp;
if (collEnt.specColl.collClass != NO_SPEC_COLL)
childDataObjInp.specColl = &collEnt.specColl;
else
childDataObjInp.specColl = NULL;
status = getCollUtil (myConn, collEnt.collName, targChildPath,
myRodsEnv, rodsArgs, &childDataObjInp, rodsRestart);
if (status < 0 && status != CAT_NO_ROWS_FOUND) {
rodsLogError (LOG_ERROR, status,
"getCollUtil: getCollUtil failed for %s. status = %d",
collEnt.collName, status);
savedStatus = status;
if (rodsRestart->fd > 0) break;
}
}
}
rclCloseCollection (&collHandle);
if (savedStatus < 0) {
return (savedStatus);
} else if (status == CAT_NO_ROWS_FOUND ||
status == SYS_SPEC_COLL_OBJ_NOT_EXIST) {
return (0);
} else {
return (status);
}
}
/*
* Gets pipe separated metadata AVUs for a data object. - from eraUtil.c
*
*/
int
getDataObjPSmeta(char *objPath, bytesBuf_t *mybuf, rsComm_t *rsComm)
{
genQueryInp_t genQueryInp;
genQueryOut_t *genQueryOut;
int i1a[10];
int i1b[10];
int i2a[10];
char *condVal[10];
char v1[MAX_NAME_LEN];
char v2[MAX_NAME_LEN];
char fullName[MAX_NAME_LEN];
char myDirName[MAX_NAME_LEN];
char myFileName[MAX_NAME_LEN];
int printCount=0;
int status;
if (rsComm == NULL) {
rodsLog (LOG_ERROR,
"getDataObjPSmeta: input rsComm is NULL");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
memset (&genQueryInp, 0, sizeof (genQueryInp_t));
i1a[0]=COL_META_DATA_ATTR_NAME;
i1b[0]=0; /* currently unused */
i1a[1]=COL_META_DATA_ATTR_VALUE;
i1b[1]=0; /* currently unused */
i1a[2]=COL_META_DATA_ATTR_UNITS;
i1b[2]=0; /* currently unused */
genQueryInp.selectInp.inx = i1a;
genQueryInp.selectInp.value = i1b;
genQueryInp.selectInp.len = 3;
/* Extract cwd name and object name */
strncpy(fullName, objPath, MAX_NAME_LEN);
status = splitPathByKey(fullName, myDirName, myFileName, '/');
i2a[0]=COL_COLL_NAME;
sprintf(v1,"='%s'",myDirName);
condVal[0]=v1;
i2a[1]=COL_DATA_NAME;
sprintf(v2,"='%s'",myFileName);
condVal[1]=v2;
genQueryInp.sqlCondInp.inx = i2a;
genQueryInp.sqlCondInp.value = condVal;
genQueryInp.sqlCondInp.len=2;
genQueryInp.maxRows=10;
genQueryInp.continueInx=0;
genQueryInp.condInput.len=0;
/* Actual query happens here */
status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
if (status == CAT_NO_ROWS_FOUND) {
i1a[0]=COL_D_DATA_PATH;
genQueryInp.selectInp.len = 1;
status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
if (status==0) {
/* printf("None\n"); */
return(0);
}
if (status == CAT_NO_ROWS_FOUND) {
rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, status,
"getDataObjPSmeta: DataObject %s not found. status = %d", fullName, status);
return (status);
}
printCount+=extractPSQueryResults(status, genQueryOut, mybuf, fullName);
}
else {
printCount+=extractPSQueryResults(status, genQueryOut, mybuf, fullName);
}
while (status==0 && genQueryOut->continueInx > 0) {
genQueryInp.continueInx=genQueryOut->continueInx;
status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
printCount+= extractPSQueryResults(status, genQueryOut, mybuf, fullName);
}
return (status);
}
