int
_rsDataObjGet( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
portalOprOut_t **portalOprOut, bytesBuf_t *dataObjOutBBuf, int handlerFlag ) {
int status;
dataObjInfo_t *dataObjInfo;
int l1descInx;
char *chksumStr = NULL;
int retval;
openedDataObjInp_t dataObjCloseInp;
/* PHYOPEN_BY_SIZE ask it to check whether "dataInclude" should be done */
addKeyVal( &dataObjInp->condInput, PHYOPEN_BY_SIZE_KW, "" );
l1descInx = _rsDataObjOpen( rsComm, dataObjInp );
if ( l1descInx < 0 ) {
return l1descInx;
}
L1desc[l1descInx].oprType = GET_OPR;
dataObjInfo = L1desc[l1descInx].dataObjInfo;
if ( getStructFileType( dataObjInfo->specColl ) >= 0 && // JMC - backport 4682
L1desc[l1descInx].l3descInx > 0 ) {
/* l3descInx == 0 if included */
*portalOprOut = ( portalOprOut_t * ) malloc( sizeof( portalOprOut_t ) );
bzero( *portalOprOut, sizeof( portalOprOut_t ) );
( *portalOprOut )->l1descInx = l1descInx;
return l1descInx;
}
if ( getValByKey( &dataObjInp->condInput, VERIFY_CHKSUM_KW ) != NULL ) {
if ( strlen( dataObjInfo->chksum ) > 0 ) {
/* a chksum already exists */
chksumStr = strdup( dataObjInfo->chksum );
}
else {
status = dataObjChksumAndReg( rsComm, dataObjInfo, &chksumStr );
if ( status < 0 ) {
return status;
}
rstrcpy( dataObjInfo->chksum, chksumStr, NAME_LEN );
}
}
if ( L1desc[l1descInx].l3descInx <= 2 ) {
/* no physical file was opened */
status = l3DataGetSingleBuf( rsComm, l1descInx, dataObjOutBBuf,
portalOprOut );
if ( status >= 0 ) {
int status2;
/** since the object is read here, we apply post procesing RAJA
* Dec 2 2010 **/
status2 = applyRuleForPostProcForRead( rsComm, dataObjOutBBuf,
dataObjInp->objPath );
if ( status2 >= 0 ) {
status = 0;
}
else {
status = status2;
}
/** since the object is read here, we apply post procesing
* RAJA Dec 2 2010 **/
if ( chksumStr != NULL ) {
rstrcpy( ( *portalOprOut )->chksum, chksumStr, NAME_LEN );
free( chksumStr );
}
}
return status;
}
status = preProcParaGet( rsComm, l1descInx, portalOprOut );
if ( status < 0 ) {
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
rsDataObjClose( rsComm, &dataObjCloseInp );
if ( chksumStr != NULL ) {
free( chksumStr );
}
return status;
}
status = l1descInx; /* means file not included */
if ( chksumStr != NULL ) {
rstrcpy( ( *portalOprOut )->chksum, chksumStr, NAME_LEN );
free( chksumStr );
}
/* return portalOprOut to the client and wait for the rcOprComplete
* call. That is when the parallel I/O is done */
retval = sendAndRecvBranchMsg( rsComm, rsComm->apiInx, status,
( void * ) * portalOprOut, dataObjOutBBuf );
if ( retval < 0 ) {
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
rsDataObjClose( rsComm, &dataObjCloseInp );
}
if ( handlerFlag & INTERNAL_SVR_CALL ) {
/* internal call. want to know the real status */
return retval;
}
else {
/* already send the client the status */
return SYS_NO_HANDLER_REPLY_MSG;
}
}
int
_rsDataObjPut( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut ) {
int status;
int l1descInx;
int retval;
openedDataObjInp_t dataObjCloseInp;
int allFlag;
transferStat_t *transStat = NULL;
dataObjInp_t replDataObjInp;
if ( getValByKey( &dataObjInp->condInput, ALL_KW ) != NULL ) {
allFlag = 1;
}
else {
allFlag = 0;
}
if ( getValByKey( &dataObjInp->condInput, DATA_INCLUDED_KW ) != NULL ) {
/* single buffer put */
status = l3DataPutSingleBuf( rsComm, dataObjInp, dataObjInpBBuf );
if ( status >= 0 && allFlag == 1 ) {
/* update the rest of copies */
addKeyVal( &dataObjInp->condInput, UPDATE_REPL_KW, "" );
status = rsDataObjRepl( rsComm, dataObjInp, &transStat );
if ( transStat != NULL ) {
free( transStat );
}
}
if ( status >= 0 ) {
status = applyRuleForPostProcForWrite(
rsComm, dataObjInpBBuf, dataObjInp->objPath );
if ( status >= 0 ) {
status = 0;
}
}
return status;
}
/* get down here. will do parallel I/O */
/* so that mmap will work */
dataObjInp->openFlags |= O_RDWR;
l1descInx = rsDataObjCreate( rsComm, dataObjInp );
if ( l1descInx < 0 ) {
return l1descInx;
}
L1desc[l1descInx].oprType = PUT_OPR;
L1desc[l1descInx].dataSize = dataObjInp->dataSize;
if ( getStructFileType( L1desc[l1descInx].dataObjInfo->specColl ) >= 0 ) { // JMC - backport 4682
*portalOprOut = ( portalOprOut_t * ) malloc( sizeof( portalOprOut_t ) );
bzero( *portalOprOut, sizeof( portalOprOut_t ) );
( *portalOprOut )->l1descInx = l1descInx;
return l1descInx;
}
status = preProcParaPut( rsComm, l1descInx, portalOprOut );
if ( status < 0 ) {
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
L1desc[l1descInx].oprStatus = status;
rsDataObjClose( rsComm, &dataObjCloseInp );
return status;
}
if ( allFlag == 1 ) {
/* need to save dataObjInp. get freed in sendAndRecvBranchMsg */
memset( &replDataObjInp, 0, sizeof( replDataObjInp ) );
rstrcpy( replDataObjInp.objPath, dataObjInp->objPath, MAX_NAME_LEN );
addKeyVal( &replDataObjInp.condInput, UPDATE_REPL_KW, "" );
addKeyVal( &replDataObjInp.condInput, ALL_KW, "" );
}
/* return portalOprOut to the client and wait for the rcOprComplete
* call. That is when the parallel I/O is done */
retval = sendAndRecvBranchMsg( rsComm, rsComm->apiInx, status,
( void * ) * portalOprOut, NULL );
if ( retval < 0 ) {
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
L1desc[l1descInx].oprStatus = retval;
rsDataObjClose( rsComm, &dataObjCloseInp );
if ( allFlag == 1 ) {
clearKeyVal( &replDataObjInp.condInput );
}
}
else if ( allFlag == 1 ) {
status = rsDataObjRepl( rsComm, &replDataObjInp, &transStat );
if ( transStat != NULL ) {
free( transStat );
}
clearKeyVal( &replDataObjInp.condInput );
}
/* already send the client the status */
return SYS_NO_HANDLER_REPLY_MSG;
}
int
rsRsyncFileToData (rsComm_t *rsComm, dataObjInp_t *dataObjInp)
{
int status;
char *fileChksumStr = NULL;
char *dataObjChksumStr = NULL;
dataObjInfo_t *dataObjInfoHead = NULL;
fileChksumStr = getValByKey (&dataObjInp->condInput, RSYNC_CHKSUM_KW);
if (fileChksumStr == NULL) {
rodsLog (LOG_ERROR,
"rsRsyncFileToData: RSYNC_CHKSUM_KW input is missing");
return (CHKSUM_EMPTY_IN_STRUCT_ERR);
}
status = _rsDataObjChksum (rsComm, dataObjInp, &dataObjChksumStr,
&dataObjInfoHead);
if (status < 0 && status != CAT_NO_ACCESS_PERMISSION &&
status != CAT_NO_ROWS_FOUND) {
/* XXXXX CAT_NO_ACCESS_PERMISSION mean the chksum was calculated but
* cannot be registered. But the chksum value is OK.
*/
rodsLog (LOG_ERROR,
"rsRsyncFileToData: _rsDataObjChksum of %s error. status = %d",
dataObjInp->objPath, status);
}
freeAllDataObjInfo (dataObjInfoHead);
if (dataObjChksumStr != NULL &&
strcmp (dataObjChksumStr, fileChksumStr) == 0) {
free (dataObjChksumStr);
return (0);
}
return SYS_SVR_TO_CLI_PUT_ACTION;
#if 0
msParamArray_t *myMsParamArray;
dataObjInp_t *myDataObjInp;
myMsParamArray = malloc (sizeof (msParamArray_t));
memset (myMsParamArray, 0, sizeof (msParamArray_t));
/* have to get its own dataObjInp_t */
myDataObjInp = malloc (sizeof (dataObjInp_t));
replDataObjInp (dataObjInp, myDataObjInp);
addKeyVal (&myDataObjInp->condInput, REG_CHKSUM_KW, fileChksumStr);
status = addMsParam (myMsParamArray, CL_PUT_ACTION, DataObjInp_MS_T,
(void *) myDataObjInp, NULL);
if (status < 0) {
rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, status,
"rsRsyncDataToFile: addMsParam error. status = %d", status);
return (status);
}
/* tell the client to do the put */
status = sendAndRecvBranchMsg (rsComm, rsComm->apiInx,
SYS_SVR_TO_CLI_MSI_REQUEST, (void *) myMsParamArray, NULL);
return (status);
#endif
}
