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 }